]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
improvements to wxPickerBase default proportion values (patch 1525578)
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_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 void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3888 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3889 #if wxUSE_HOTKEY
3890 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3891 #else
3892 return false;
3893 #endif
3894 }
3895 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3896
3897
3898
3899 return false;
3900
3901 }
3902 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3903 return wxPyGetWinHandle(self);
3904 }
3905 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3906 self->AssociateHandle((WXWidget)handle);
3907 }
3908 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3909
3910 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3911 return wxWindow::FindWindowById(id, parent);
3912 }
3913
3914 wxWindow* wxFindWindowByName( const wxString& name,
3915 const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowByName(name, parent);
3917 }
3918
3919 wxWindow* wxFindWindowByLabel( const wxString& label,
3920 const wxWindow *parent = NULL ) {
3921 return wxWindow::FindWindowByLabel(label, parent);
3922 }
3923
3924
3925 #ifdef __WXMSW__
3926 #include <wx/msw/private.h> // to get wxGetWindowId
3927 #endif
3928
3929
3930 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3931 #ifdef __WXMSW__
3932 WXHWND hWnd = (WXHWND)_hWnd;
3933 long id = wxGetWindowId(hWnd);
3934 wxWindow* win = new wxWindow;
3935 if (parent)
3936 parent->AddChild(win);
3937 win->SetEventHandler(win);
3938 win->SetHWND(hWnd);
3939 win->SetId(id);
3940 win->SubclassWin(hWnd);
3941 win->AdoptAttributesFromHWND();
3942 win->SetupColours();
3943 return win;
3944 #else
3945 wxPyRaiseNotImplemented();
3946 return NULL;
3947 #endif
3948 }
3949
3950
3951 PyObject* GetTopLevelWindows() {
3952 return wxPy_ConvertList(&wxTopLevelWindows);
3953 }
3954
3955
3956 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3958 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3959
3960 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3961
3962
3963 SWIGINTERNINLINE int
3964 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3965 {
3966 unsigned long v;
3967 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3968 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3969 return res;
3970 }
3971
3972 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3973 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3974 wxMenuItemList& list = self->GetMenuItems();
3975 return wxPy_ConvertList(&list);
3976 }
3977 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3978 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3979 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3980 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3981 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3982 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3983 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3984 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3985 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3986 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3987 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3988 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3989 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3990 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3991 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3992 static const wxString wxPyControlNameStr(wxControlNameStr);
3993 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3994 if (clientData) {
3995 wxPyClientData* data = new wxPyClientData(clientData);
3996 return self->Append(item, data);
3997 } else
3998 return self->Append(item);
3999 }
4000 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4001 if (clientData) {
4002 wxPyClientData* data = new wxPyClientData(clientData);
4003 return self->Insert(item, pos, data);
4004 } else
4005 return self->Insert(item, pos);
4006 }
4007 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4008 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4009 if (data) {
4010 Py_INCREF(data->m_obj);
4011 return data->m_obj;
4012 } else {
4013 Py_INCREF(Py_None);
4014 return Py_None;
4015 }
4016 }
4017 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4018 wxPyClientData* data = new wxPyClientData(clientData);
4019 self->SetClientObject(n, data);
4020 }
4021
4022
4023 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 return new wxSizerItem(window, proportion, flag, border, data);
4031 }
4032 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4033 wxPyUserData* data = NULL;
4034 if ( userData ) {
4035 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4036 data = new wxPyUserData(userData);
4037 wxPyEndBlockThreads(blocked);
4038 }
4039 return new wxSizerItem(width, height, proportion, flag, border, data);
4040 }
4041 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4042 wxPyUserData* data = NULL;
4043 if ( userData ) {
4044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4045 data = new wxPyUserData(userData);
4046 wxPyEndBlockThreads(blocked);
4047 }
4048 return new wxSizerItem(sizer, proportion, flag, border, data);
4049 }
4050
4051 SWIGINTERNINLINE PyObject *
4052 SWIG_From_float (float value)
4053 {
4054 return SWIG_From_double (value);
4055 }
4056
4057 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4058 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4059 if (data) {
4060 Py_INCREF(data->m_obj);
4061 return data->m_obj;
4062 } else {
4063 Py_INCREF(Py_None);
4064 return Py_None;
4065 }
4066 }
4067 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4068 wxPyUserData* data = NULL;
4069 if ( userData ) {
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 data = new wxPyUserData(userData);
4072 wxPyEndBlockThreads(blocked);
4073 }
4074 self->SetUserData(data);
4075 }
4076
4077 // Figure out the type of the sizer item
4078
4079 struct wxPySizerItemInfo {
4080 wxPySizerItemInfo()
4081 : window(NULL), sizer(NULL), gotSize(false),
4082 size(wxDefaultSize), gotPos(false), pos(-1)
4083 {}
4084
4085 wxWindow* window;
4086 wxSizer* sizer;
4087 bool gotSize;
4088 wxSize size;
4089 bool gotPos;
4090 int pos;
4091 };
4092
4093 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4094
4095 wxPySizerItemInfo info;
4096 wxSize size;
4097 wxSize* sizePtr = &size;
4098
4099 // Find out what the type of the item is
4100 // try wxWindow
4101 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4102 PyErr_Clear();
4103 info.window = NULL;
4104
4105 // try wxSizer
4106 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4107 PyErr_Clear();
4108 info.sizer = NULL;
4109
4110 // try wxSize or (w,h)
4111 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4112 info.size = *sizePtr;
4113 info.gotSize = true;
4114 }
4115
4116 // or a single int
4117 if (checkIdx && PyInt_Check(item)) {
4118 info.pos = PyInt_AsLong(item);
4119 info.gotPos = true;
4120 }
4121 }
4122 }
4123
4124 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4125 // no expected type, figure out what kind of error message to generate
4126 if ( !checkSize && !checkIdx )
4127 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4128 else if ( checkSize && !checkIdx )
4129 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4130 else if ( !checkSize && checkIdx)
4131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4132 else
4133 // can this one happen?
4134 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4135 }
4136
4137 return info;
4138 }
4139
4140 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4141 if (!self->GetClientObject())
4142 self->SetClientObject(new wxPyOORClientData(_self));
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Add method if a valid item type was found
4156 if ( info.window )
4157 return self->Add(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Add(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4167
4168 wxPyUserData* data = NULL;
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4171 if ( userData && (info.window || info.sizer || info.gotSize) )
4172 data = new wxPyUserData(userData);
4173 if ( info.sizer )
4174 PyObject_SetAttrString(item,"thisown",Py_False);
4175 wxPyEndBlockThreads(blocked);
4176
4177 // Now call the real Insert method if a valid item type was found
4178 if ( info.window )
4179 return self->Insert(before, info.window, proportion, flag, border, data);
4180 else if ( info.sizer )
4181 return self->Insert(before, info.sizer, proportion, flag, border, data);
4182 else if (info.gotSize)
4183 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4184 proportion, flag, border, data);
4185 else
4186 return NULL;
4187 }
4188 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4189
4190 wxPyUserData* data = NULL;
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4193 if ( userData && (info.window || info.sizer || info.gotSize) )
4194 data = new wxPyUserData(userData);
4195 if ( info.sizer )
4196 PyObject_SetAttrString(item,"thisown",Py_False);
4197 wxPyEndBlockThreads(blocked);
4198
4199 // Now call the real Prepend method if a valid item type was found
4200 if ( info.window )
4201 return self->Prepend(info.window, proportion, flag, border, data);
4202 else if ( info.sizer )
4203 return self->Prepend(info.sizer, proportion, flag, border, data);
4204 else if (info.gotSize)
4205 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4206 proportion, flag, border, data);
4207 else
4208 return NULL;
4209 }
4210 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4211 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4212 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4213 wxPyEndBlockThreads(blocked);
4214 if ( info.window )
4215 return self->Remove(info.window);
4216 else if ( info.sizer )
4217 return self->Remove(info.sizer);
4218 else if ( info.gotPos )
4219 return self->Remove(info.pos);
4220 else
4221 return false;
4222 }
4223 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4226 wxPyEndBlockThreads(blocked);
4227 if ( info.window )
4228 return self->Detach(info.window);
4229 else if ( info.sizer )
4230 return self->Detach(info.sizer);
4231 else if ( info.gotPos )
4232 return self->Detach(info.pos);
4233 else
4234 return false;
4235 }
4236 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4237 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4238 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4239 wxPyEndBlockThreads(blocked);
4240 if ( info.window )
4241 return self->GetItem(info.window);
4242 else if ( info.sizer )
4243 return self->GetItem(info.sizer);
4244 else if ( info.gotPos )
4245 return self->GetItem(info.pos);
4246 else
4247 return NULL;
4248 }
4249 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4252 wxPyEndBlockThreads(blocked);
4253 if ( info.window )
4254 self->SetItemMinSize(info.window, size);
4255 else if ( info.sizer )
4256 self->SetItemMinSize(info.sizer, size);
4257 else if ( info.gotPos )
4258 self->SetItemMinSize(info.pos, size);
4259 }
4260 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4261 wxSizerItemList& list = self->GetChildren();
4262 return wxPy_ConvertList(&list);
4263 }
4264 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4265 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4266 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4267 wxPyEndBlockThreads(blocked);
4268 if ( info.window )
4269 return self->Show(info.window, show, recursive);
4270 else if ( info.sizer )
4271 return self->Show(info.sizer, show, recursive);
4272 else if ( info.gotPos )
4273 return self->Show(info.pos, show);
4274 else
4275 return false;
4276 }
4277 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4279 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4280 wxPyEndBlockThreads(blocked);
4281 if ( info.window )
4282 return self->IsShown(info.window);
4283 else if ( info.sizer )
4284 return self->IsShown(info.sizer);
4285 else if ( info.gotPos )
4286 return self->IsShown(info.pos);
4287 else
4288 return false;
4289 }
4290
4291 // See pyclasses.h
4292 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4293 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4294 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4295
4296
4297
4298
4299 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4300 {
4301 if (source == Py_None) {
4302 **obj = wxGBPosition(-1,-1);
4303 return true;
4304 }
4305 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4306 }
4307
4308 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4309 {
4310 if (source == Py_None) {
4311 **obj = wxGBSpan(-1,-1);
4312 return true;
4313 }
4314 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4315 }
4316
4317
4318 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4319 wxGBPosition temp, *obj = &temp;
4320 if ( other == Py_None ) return false;
4321 if ( ! wxGBPosition_helper(other, &obj) ) {
4322 PyErr_Clear();
4323 return false;
4324 }
4325 return self->operator==(*obj);
4326 }
4327 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4328 wxGBPosition temp, *obj = &temp;
4329 if ( other == Py_None ) return true;
4330 if ( ! wxGBPosition_helper(other, &obj)) {
4331 PyErr_Clear();
4332 return true;
4333 }
4334 return self->operator!=(*obj);
4335 }
4336 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4337 self->SetRow(row);
4338 self->SetCol(col);
4339 }
4340 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4342 PyObject* tup = PyTuple_New(2);
4343 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4344 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4345 wxPyEndBlockThreads(blocked);
4346 return tup;
4347 }
4348 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4349 wxGBSpan temp, *obj = &temp;
4350 if ( other == Py_None ) return false;
4351 if ( ! wxGBSpan_helper(other, &obj) ) {
4352 PyErr_Clear();
4353 return false;
4354 }
4355 return self->operator==(*obj);
4356 }
4357 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4358 wxGBSpan temp, *obj = &temp;
4359 if ( other == Py_None ) return true;
4360 if ( ! wxGBSpan_helper(other, &obj)) {
4361 PyErr_Clear();
4362 return true;
4363 }
4364 return self->operator!=(*obj);
4365 }
4366 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4367 self->SetRowspan(rowspan);
4368 self->SetColspan(colspan);
4369 }
4370 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 PyObject* tup = PyTuple_New(2);
4373 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4374 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4375 wxPyEndBlockThreads(blocked);
4376 return tup;
4377 }
4378 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4379 wxPyUserData* data = NULL;
4380 if ( userData ) {
4381 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4382 data = new wxPyUserData(userData);
4383 wxPyEndBlockThreads(blocked);
4384 }
4385 return new wxGBSizerItem(window, pos, span, flag, border, data);
4386 }
4387 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4388 wxPyUserData* data = NULL;
4389 if ( userData ) {
4390 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4391 data = new wxPyUserData(userData);
4392 wxPyEndBlockThreads(blocked);
4393 }
4394 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4395 }
4396 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4397 wxPyUserData* data = NULL;
4398 if ( userData ) {
4399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4400 data = new wxPyUserData(userData);
4401 wxPyEndBlockThreads(blocked);
4402 }
4403 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4404 }
4405 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4406 int row, col;
4407 self->GetEndPos(row, col);
4408 return wxGBPosition(row, col);
4409 }
4410 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4411
4412 wxPyUserData* data = NULL;
4413 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4414 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4415 if ( userData && (info.window || info.sizer || info.gotSize) )
4416 data = new wxPyUserData(userData);
4417 if ( info.sizer )
4418 PyObject_SetAttrString(item,"thisown",Py_False);
4419 wxPyEndBlockThreads(blocked);
4420
4421 // Now call the real Add method if a valid item type was found
4422 if ( info.window )
4423 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4424 else if ( info.sizer )
4425 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4426 else if (info.gotSize)
4427 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4428 pos, span, flag, border, data);
4429 return NULL;
4430 }
4431
4432
4433 #ifdef __cplusplus
4434 extern "C" {
4435 #endif
4436 SWIGINTERN int EmptyString_set(PyObject *) {
4437 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4438 return 1;
4439 }
4440
4441
4442 SWIGINTERN PyObject *EmptyString_get(void) {
4443 PyObject *pyobj = 0;
4444
4445 {
4446 #if wxUSE_UNICODE
4447 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4448 #else
4449 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4450 #endif
4451 }
4452 return pyobj;
4453 }
4454
4455
4456 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 wxObject *arg1 = (wxObject *) 0 ;
4459 wxString result;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 PyObject *swig_obj[1] ;
4463
4464 if (!args) SWIG_fail;
4465 swig_obj[0] = args;
4466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4467 if (!SWIG_IsOK(res1)) {
4468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4469 }
4470 arg1 = reinterpret_cast< wxObject * >(argp1);
4471 {
4472 PyThreadState* __tstate = wxPyBeginAllowThreads();
4473 result = wxObject_GetClassName(arg1);
4474 wxPyEndAllowThreads(__tstate);
4475 if (PyErr_Occurred()) SWIG_fail;
4476 }
4477 {
4478 #if wxUSE_UNICODE
4479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4480 #else
4481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4482 #endif
4483 }
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxObject *arg1 = (wxObject *) 0 ;
4493 void *argp1 = 0 ;
4494 int res1 = 0 ;
4495 PyObject *swig_obj[1] ;
4496
4497 if (!args) SWIG_fail;
4498 swig_obj[0] = args;
4499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4500 if (!SWIG_IsOK(res1)) {
4501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4502 }
4503 arg1 = reinterpret_cast< wxObject * >(argp1);
4504 {
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 wxObject_Destroy(arg1);
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 resultobj = SWIG_Py_Void();
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj = 0;
4519 wxObject *arg1 = (wxObject *) 0 ;
4520 wxObject *arg2 = 0 ;
4521 bool result;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 void *argp2 = 0 ;
4525 int res2 = 0 ;
4526 PyObject * obj0 = 0 ;
4527 PyObject * obj1 = 0 ;
4528 char * kwnames[] = {
4529 (char *) "self",(char *) "p", NULL
4530 };
4531
4532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4534 if (!SWIG_IsOK(res1)) {
4535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4536 }
4537 arg1 = reinterpret_cast< wxObject * >(argp1);
4538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4539 if (!SWIG_IsOK(res2)) {
4540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4541 }
4542 if (!argp2) {
4543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4544 }
4545 arg2 = reinterpret_cast< wxObject * >(argp2);
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4562 PyObject *obj;
4563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4564 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4565 return SWIG_Py_Void();
4566 }
4567
4568 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4569 PyObject *resultobj = 0;
4570 wxSize *arg1 = (wxSize *) 0 ;
4571 int arg2 ;
4572 void *argp1 = 0 ;
4573 int res1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject *swig_obj[2] ;
4577
4578 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4580 if (!SWIG_IsOK(res1)) {
4581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4582 }
4583 arg1 = reinterpret_cast< wxSize * >(argp1);
4584 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4585 if (!SWIG_IsOK(ecode2)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4587 }
4588 arg2 = static_cast< int >(val2);
4589 if (arg1) (arg1)->x = arg2;
4590
4591 resultobj = SWIG_Py_Void();
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 int result;
4602 void *argp1 = 0 ;
4603 int res1 = 0 ;
4604 PyObject *swig_obj[1] ;
4605
4606 if (!args) SWIG_fail;
4607 swig_obj[0] = args;
4608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4611 }
4612 arg1 = reinterpret_cast< wxSize * >(argp1);
4613 result = (int) ((arg1)->x);
4614 resultobj = SWIG_From_int(static_cast< int >(result));
4615 return resultobj;
4616 fail:
4617 return NULL;
4618 }
4619
4620
4621 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622 PyObject *resultobj = 0;
4623 wxSize *arg1 = (wxSize *) 0 ;
4624 int arg2 ;
4625 void *argp1 = 0 ;
4626 int res1 = 0 ;
4627 int val2 ;
4628 int ecode2 = 0 ;
4629 PyObject *swig_obj[2] ;
4630
4631 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4633 if (!SWIG_IsOK(res1)) {
4634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4635 }
4636 arg1 = reinterpret_cast< wxSize * >(argp1);
4637 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4638 if (!SWIG_IsOK(ecode2)) {
4639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4640 }
4641 arg2 = static_cast< int >(val2);
4642 if (arg1) (arg1)->y = arg2;
4643
4644 resultobj = SWIG_Py_Void();
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4652 PyObject *resultobj = 0;
4653 wxSize *arg1 = (wxSize *) 0 ;
4654 int result;
4655 void *argp1 = 0 ;
4656 int res1 = 0 ;
4657 PyObject *swig_obj[1] ;
4658
4659 if (!args) SWIG_fail;
4660 swig_obj[0] = args;
4661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4664 }
4665 arg1 = reinterpret_cast< wxSize * >(argp1);
4666 result = (int) ((arg1)->y);
4667 resultobj = SWIG_From_int(static_cast< int >(result));
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 int arg1 = (int) 0 ;
4677 int arg2 = (int) 0 ;
4678 wxSize *result = 0 ;
4679 int val1 ;
4680 int ecode1 = 0 ;
4681 int val2 ;
4682 int ecode2 = 0 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "w",(char *) "h", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4690 if (obj0) {
4691 ecode1 = SWIG_AsVal_int(obj0, &val1);
4692 if (!SWIG_IsOK(ecode1)) {
4693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4694 }
4695 arg1 = static_cast< int >(val1);
4696 }
4697 if (obj1) {
4698 ecode2 = SWIG_AsVal_int(obj1, &val2);
4699 if (!SWIG_IsOK(ecode2)) {
4700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4701 }
4702 arg2 = static_cast< int >(val2);
4703 }
4704 {
4705 result = (wxSize *)new wxSize(arg1,arg2);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4709 return resultobj;
4710 fail:
4711 return NULL;
4712 }
4713
4714
4715 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4716 PyObject *resultobj = 0;
4717 wxSize *arg1 = (wxSize *) 0 ;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 PyObject *swig_obj[1] ;
4721
4722 if (!args) SWIG_fail;
4723 swig_obj[0] = args;
4724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4727 }
4728 arg1 = reinterpret_cast< wxSize * >(argp1);
4729 {
4730 delete arg1;
4731
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_Py_Void();
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
4744 PyObject *arg2 = (PyObject *) 0 ;
4745 bool result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "self",(char *) "other", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4758 }
4759 arg1 = reinterpret_cast< wxSize * >(argp1);
4760 arg2 = obj1;
4761 {
4762 result = (bool)wxSize___eq__(arg1,arg2);
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 {
4766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4767 }
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
4777 PyObject *arg2 = (PyObject *) 0 ;
4778 bool result;
4779 void *argp1 = 0 ;
4780 int res1 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "self",(char *) "other", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4791 }
4792 arg1 = reinterpret_cast< wxSize * >(argp1);
4793 arg2 = obj1;
4794 {
4795 result = (bool)wxSize___ne__(arg1,arg2);
4796 if (PyErr_Occurred()) SWIG_fail;
4797 }
4798 {
4799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4800 }
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = 0;
4809 wxSize *arg1 = (wxSize *) 0 ;
4810 wxSize *arg2 = 0 ;
4811 wxSize result;
4812 void *argp1 = 0 ;
4813 int res1 = 0 ;
4814 wxSize temp2 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char * kwnames[] = {
4818 (char *) "self",(char *) "sz", NULL
4819 };
4820
4821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 {
4828 arg2 = &temp2;
4829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4830 }
4831 {
4832 result = (arg1)->operator +((wxSize const &)*arg2);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4836 return resultobj;
4837 fail:
4838 return NULL;
4839 }
4840
4841
4842 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj = 0;
4844 wxSize *arg1 = (wxSize *) 0 ;
4845 wxSize *arg2 = 0 ;
4846 wxSize result;
4847 void *argp1 = 0 ;
4848 int res1 = 0 ;
4849 wxSize temp2 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "self",(char *) "sz", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 {
4863 arg2 = &temp2;
4864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4865 }
4866 {
4867 result = (arg1)->operator -((wxSize const &)*arg2);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 wxSize *arg1 = (wxSize *) 0 ;
4880 wxSize *arg2 = 0 ;
4881 void *argp1 = 0 ;
4882 int res1 = 0 ;
4883 wxSize temp2 ;
4884 PyObject * obj0 = 0 ;
4885 PyObject * obj1 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "sz", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4894 }
4895 arg1 = reinterpret_cast< wxSize * >(argp1);
4896 {
4897 arg2 = &temp2;
4898 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4899 }
4900 {
4901 (arg1)->IncTo((wxSize const &)*arg2);
4902 if (PyErr_Occurred()) SWIG_fail;
4903 }
4904 resultobj = SWIG_Py_Void();
4905 return resultobj;
4906 fail:
4907 return NULL;
4908 }
4909
4910
4911 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4912 PyObject *resultobj = 0;
4913 wxSize *arg1 = (wxSize *) 0 ;
4914 wxSize *arg2 = 0 ;
4915 void *argp1 = 0 ;
4916 int res1 = 0 ;
4917 wxSize temp2 ;
4918 PyObject * obj0 = 0 ;
4919 PyObject * obj1 = 0 ;
4920 char * kwnames[] = {
4921 (char *) "self",(char *) "sz", NULL
4922 };
4923
4924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4926 if (!SWIG_IsOK(res1)) {
4927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4928 }
4929 arg1 = reinterpret_cast< wxSize * >(argp1);
4930 {
4931 arg2 = &temp2;
4932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4933 }
4934 {
4935 (arg1)->DecTo((wxSize const &)*arg2);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 resultobj = SWIG_Py_Void();
4939 return resultobj;
4940 fail:
4941 return NULL;
4942 }
4943
4944
4945 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj = 0;
4947 wxSize *arg1 = (wxSize *) 0 ;
4948 int arg2 ;
4949 int arg3 ;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 int val2 ;
4953 int ecode2 = 0 ;
4954 int val3 ;
4955 int ecode3 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 PyObject * obj2 = 0 ;
4959 char * kwnames[] = {
4960 (char *) "self",(char *) "dx",(char *) "dy", NULL
4961 };
4962
4963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4965 if (!SWIG_IsOK(res1)) {
4966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4967 }
4968 arg1 = reinterpret_cast< wxSize * >(argp1);
4969 ecode2 = SWIG_AsVal_int(obj1, &val2);
4970 if (!SWIG_IsOK(ecode2)) {
4971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4972 }
4973 arg2 = static_cast< int >(val2);
4974 ecode3 = SWIG_AsVal_int(obj2, &val3);
4975 if (!SWIG_IsOK(ecode3)) {
4976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4977 }
4978 arg3 = static_cast< int >(val3);
4979 {
4980 (arg1)->IncBy(arg2,arg3);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_Py_Void();
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4991 PyObject *resultobj = 0;
4992 wxSize *arg1 = (wxSize *) 0 ;
4993 int arg2 ;
4994 int arg3 ;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 int val2 ;
4998 int ecode2 = 0 ;
4999 int val3 ;
5000 int ecode3 = 0 ;
5001 PyObject * obj0 = 0 ;
5002 PyObject * obj1 = 0 ;
5003 PyObject * obj2 = 0 ;
5004 char * kwnames[] = {
5005 (char *) "self",(char *) "dx",(char *) "dy", NULL
5006 };
5007
5008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5010 if (!SWIG_IsOK(res1)) {
5011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5012 }
5013 arg1 = reinterpret_cast< wxSize * >(argp1);
5014 ecode2 = SWIG_AsVal_int(obj1, &val2);
5015 if (!SWIG_IsOK(ecode2)) {
5016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5017 }
5018 arg2 = static_cast< int >(val2);
5019 ecode3 = SWIG_AsVal_int(obj2, &val3);
5020 if (!SWIG_IsOK(ecode3)) {
5021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5022 }
5023 arg3 = static_cast< int >(val3);
5024 {
5025 (arg1)->DecBy(arg2,arg3);
5026 if (PyErr_Occurred()) SWIG_fail;
5027 }
5028 resultobj = SWIG_Py_Void();
5029 return resultobj;
5030 fail:
5031 return NULL;
5032 }
5033
5034
5035 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5036 PyObject *resultobj = 0;
5037 wxSize *arg1 = (wxSize *) 0 ;
5038 float arg2 ;
5039 float arg3 ;
5040 void *argp1 = 0 ;
5041 int res1 = 0 ;
5042 float val2 ;
5043 int ecode2 = 0 ;
5044 float val3 ;
5045 int ecode3 = 0 ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 PyObject * obj2 = 0 ;
5049 char * kwnames[] = {
5050 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5051 };
5052
5053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5055 if (!SWIG_IsOK(res1)) {
5056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5057 }
5058 arg1 = reinterpret_cast< wxSize * >(argp1);
5059 ecode2 = SWIG_AsVal_float(obj1, &val2);
5060 if (!SWIG_IsOK(ecode2)) {
5061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5062 }
5063 arg2 = static_cast< float >(val2);
5064 ecode3 = SWIG_AsVal_float(obj2, &val3);
5065 if (!SWIG_IsOK(ecode3)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5067 }
5068 arg3 = static_cast< float >(val3);
5069 {
5070 (arg1)->Scale(arg2,arg3);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_Py_Void();
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 int arg2 ;
5084 int arg3 ;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 int val2 ;
5088 int ecode2 = 0 ;
5089 int val3 ;
5090 int ecode3 = 0 ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 char * kwnames[] = {
5095 (char *) "self",(char *) "w",(char *) "h", NULL
5096 };
5097
5098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5102 }
5103 arg1 = reinterpret_cast< wxSize * >(argp1);
5104 ecode2 = SWIG_AsVal_int(obj1, &val2);
5105 if (!SWIG_IsOK(ecode2)) {
5106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5107 }
5108 arg2 = static_cast< int >(val2);
5109 ecode3 = SWIG_AsVal_int(obj2, &val3);
5110 if (!SWIG_IsOK(ecode3)) {
5111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5112 }
5113 arg3 = static_cast< int >(val3);
5114 {
5115 (arg1)->Set(arg2,arg3);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 resultobj = SWIG_Py_Void();
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 int arg2 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 int val2 ;
5132 int ecode2 = 0 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "w", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 ecode2 = SWIG_AsVal_int(obj1, &val2);
5146 if (!SWIG_IsOK(ecode2)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5148 }
5149 arg2 = static_cast< int >(val2);
5150 {
5151 (arg1)->SetWidth(arg2);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 int arg2 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 int val2 ;
5168 int ecode2 = 0 ;
5169 PyObject * obj0 = 0 ;
5170 PyObject * obj1 = 0 ;
5171 char * kwnames[] = {
5172 (char *) "self",(char *) "h", NULL
5173 };
5174
5175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5177 if (!SWIG_IsOK(res1)) {
5178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5179 }
5180 arg1 = reinterpret_cast< wxSize * >(argp1);
5181 ecode2 = SWIG_AsVal_int(obj1, &val2);
5182 if (!SWIG_IsOK(ecode2)) {
5183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5184 }
5185 arg2 = static_cast< int >(val2);
5186 {
5187 (arg1)->SetHeight(arg2);
5188 if (PyErr_Occurred()) SWIG_fail;
5189 }
5190 resultobj = SWIG_Py_Void();
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 PyObject *resultobj = 0;
5199 wxSize *arg1 = (wxSize *) 0 ;
5200 int result;
5201 void *argp1 = 0 ;
5202 int res1 = 0 ;
5203 PyObject *swig_obj[1] ;
5204
5205 if (!args) SWIG_fail;
5206 swig_obj[0] = args;
5207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5208 if (!SWIG_IsOK(res1)) {
5209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5210 }
5211 arg1 = reinterpret_cast< wxSize * >(argp1);
5212 {
5213 result = (int)((wxSize const *)arg1)->GetWidth();
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 resultobj = SWIG_From_int(static_cast< int >(result));
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5224 PyObject *resultobj = 0;
5225 wxSize *arg1 = (wxSize *) 0 ;
5226 int result;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 PyObject *swig_obj[1] ;
5230
5231 if (!args) SWIG_fail;
5232 swig_obj[0] = args;
5233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5234 if (!SWIG_IsOK(res1)) {
5235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5236 }
5237 arg1 = reinterpret_cast< wxSize * >(argp1);
5238 {
5239 result = (int)((wxSize const *)arg1)->GetHeight();
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 resultobj = SWIG_From_int(static_cast< int >(result));
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5250 PyObject *resultobj = 0;
5251 wxSize *arg1 = (wxSize *) 0 ;
5252 bool result;
5253 void *argp1 = 0 ;
5254 int res1 = 0 ;
5255 PyObject *swig_obj[1] ;
5256
5257 if (!args) SWIG_fail;
5258 swig_obj[0] = args;
5259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5260 if (!SWIG_IsOK(res1)) {
5261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5262 }
5263 arg1 = reinterpret_cast< wxSize * >(argp1);
5264 {
5265 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 {
5269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5270 }
5271 return resultobj;
5272 fail:
5273 return NULL;
5274 }
5275
5276
5277 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj = 0;
5279 wxSize *arg1 = (wxSize *) 0 ;
5280 wxSize *arg2 = 0 ;
5281 void *argp1 = 0 ;
5282 int res1 = 0 ;
5283 wxSize temp2 ;
5284 PyObject * obj0 = 0 ;
5285 PyObject * obj1 = 0 ;
5286 char * kwnames[] = {
5287 (char *) "self",(char *) "size", NULL
5288 };
5289
5290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5292 if (!SWIG_IsOK(res1)) {
5293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5294 }
5295 arg1 = reinterpret_cast< wxSize * >(argp1);
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
5301 (arg1)->SetDefaults((wxSize const &)*arg2);
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxSize *arg1 = (wxSize *) 0 ;
5314 PyObject *result = 0 ;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject *swig_obj[1] ;
5318
5319 if (!args) SWIG_fail;
5320 swig_obj[0] = args;
5321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5324 }
5325 arg1 = reinterpret_cast< wxSize * >(argp1);
5326 {
5327 result = (PyObject *)wxSize_Get(arg1);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = result;
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5338 PyObject *obj;
5339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5340 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5341 return SWIG_Py_Void();
5342 }
5343
5344 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 return SWIG_Python_InitShadowInstance(args);
5346 }
5347
5348 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5349 PyObject *resultobj = 0;
5350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5351 double arg2 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 double val2 ;
5355 int ecode2 = 0 ;
5356 PyObject *swig_obj[2] ;
5357
5358 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5365 if (!SWIG_IsOK(ecode2)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5367 }
5368 arg2 = static_cast< double >(val2);
5369 if (arg1) (arg1)->x = arg2;
5370
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 double result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject *swig_obj[1] ;
5385
5386 if (!args) SWIG_fail;
5387 swig_obj[0] = args;
5388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5391 }
5392 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5393 result = (double) ((arg1)->x);
5394 resultobj = SWIG_From_double(static_cast< double >(result));
5395 return resultobj;
5396 fail:
5397 return NULL;
5398 }
5399
5400
5401 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5402 PyObject *resultobj = 0;
5403 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5404 double arg2 ;
5405 void *argp1 = 0 ;
5406 int res1 = 0 ;
5407 double val2 ;
5408 int ecode2 = 0 ;
5409 PyObject *swig_obj[2] ;
5410
5411 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5413 if (!SWIG_IsOK(res1)) {
5414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5415 }
5416 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5417 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5418 if (!SWIG_IsOK(ecode2)) {
5419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5420 }
5421 arg2 = static_cast< double >(val2);
5422 if (arg1) (arg1)->y = arg2;
5423
5424 resultobj = SWIG_Py_Void();
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 PyObject *resultobj = 0;
5433 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5434 double result;
5435 void *argp1 = 0 ;
5436 int res1 = 0 ;
5437 PyObject *swig_obj[1] ;
5438
5439 if (!args) SWIG_fail;
5440 swig_obj[0] = args;
5441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 result = (double) ((arg1)->y);
5447 resultobj = SWIG_From_double(static_cast< double >(result));
5448 return resultobj;
5449 fail:
5450 return NULL;
5451 }
5452
5453
5454 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj = 0;
5456 double arg1 = (double) 0.0 ;
5457 double arg2 = (double) 0.0 ;
5458 wxRealPoint *result = 0 ;
5459 double val1 ;
5460 int ecode1 = 0 ;
5461 double val2 ;
5462 int ecode2 = 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char * kwnames[] = {
5466 (char *) "x",(char *) "y", NULL
5467 };
5468
5469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5470 if (obj0) {
5471 ecode1 = SWIG_AsVal_double(obj0, &val1);
5472 if (!SWIG_IsOK(ecode1)) {
5473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5474 }
5475 arg1 = static_cast< double >(val1);
5476 }
5477 if (obj1) {
5478 ecode2 = SWIG_AsVal_double(obj1, &val2);
5479 if (!SWIG_IsOK(ecode2)) {
5480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5481 }
5482 arg2 = static_cast< double >(val2);
5483 }
5484 {
5485 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5486 if (PyErr_Occurred()) SWIG_fail;
5487 }
5488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5489 return resultobj;
5490 fail:
5491 return NULL;
5492 }
5493
5494
5495 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5496 PyObject *resultobj = 0;
5497 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5498 void *argp1 = 0 ;
5499 int res1 = 0 ;
5500 PyObject *swig_obj[1] ;
5501
5502 if (!args) SWIG_fail;
5503 swig_obj[0] = args;
5504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5505 if (!SWIG_IsOK(res1)) {
5506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5507 }
5508 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5509 {
5510 delete arg1;
5511
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = SWIG_Py_Void();
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj = 0;
5523 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5524 PyObject *arg2 = (PyObject *) 0 ;
5525 bool result;
5526 void *argp1 = 0 ;
5527 int res1 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 char * kwnames[] = {
5531 (char *) "self",(char *) "other", NULL
5532 };
5533
5534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5536 if (!SWIG_IsOK(res1)) {
5537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5538 }
5539 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5540 arg2 = obj1;
5541 {
5542 result = (bool)wxRealPoint___eq__(arg1,arg2);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5547 }
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5555 PyObject *resultobj = 0;
5556 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5557 PyObject *arg2 = (PyObject *) 0 ;
5558 bool result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
5561 PyObject * obj0 = 0 ;
5562 PyObject * obj1 = 0 ;
5563 char * kwnames[] = {
5564 (char *) "self",(char *) "other", NULL
5565 };
5566
5567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5569 if (!SWIG_IsOK(res1)) {
5570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5571 }
5572 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5573 arg2 = obj1;
5574 {
5575 result = (bool)wxRealPoint___ne__(arg1,arg2);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5580 }
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj = 0;
5589 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5590 wxRealPoint *arg2 = 0 ;
5591 wxRealPoint result;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 wxRealPoint temp2 ;
5595 PyObject * obj0 = 0 ;
5596 PyObject * obj1 = 0 ;
5597 char * kwnames[] = {
5598 (char *) "self",(char *) "pt", NULL
5599 };
5600
5601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5605 }
5606 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5607 {
5608 arg2 = &temp2;
5609 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5610 }
5611 {
5612 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = 0;
5624 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5625 wxRealPoint *arg2 = 0 ;
5626 wxRealPoint result;
5627 void *argp1 = 0 ;
5628 int res1 = 0 ;
5629 wxRealPoint temp2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char * kwnames[] = {
5633 (char *) "self",(char *) "pt", NULL
5634 };
5635
5636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5638 if (!SWIG_IsOK(res1)) {
5639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5640 }
5641 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5642 {
5643 arg2 = &temp2;
5644 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5645 }
5646 {
5647 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = 0;
5659 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5660 double arg2 ;
5661 double arg3 ;
5662 void *argp1 = 0 ;
5663 int res1 = 0 ;
5664 double val2 ;
5665 int ecode2 = 0 ;
5666 double val3 ;
5667 int ecode3 = 0 ;
5668 PyObject * obj0 = 0 ;
5669 PyObject * obj1 = 0 ;
5670 PyObject * obj2 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "x",(char *) "y", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5681 ecode2 = SWIG_AsVal_double(obj1, &val2);
5682 if (!SWIG_IsOK(ecode2)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5684 }
5685 arg2 = static_cast< double >(val2);
5686 ecode3 = SWIG_AsVal_double(obj2, &val3);
5687 if (!SWIG_IsOK(ecode3)) {
5688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5689 }
5690 arg3 = static_cast< double >(val3);
5691 {
5692 wxRealPoint_Set(arg1,arg2,arg3);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 resultobj = SWIG_Py_Void();
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5703 PyObject *resultobj = 0;
5704 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5705 PyObject *result = 0 ;
5706 void *argp1 = 0 ;
5707 int res1 = 0 ;
5708 PyObject *swig_obj[1] ;
5709
5710 if (!args) SWIG_fail;
5711 swig_obj[0] = args;
5712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5717 {
5718 result = (PyObject *)wxRealPoint_Get(arg1);
5719 if (PyErr_Occurred()) SWIG_fail;
5720 }
5721 resultobj = result;
5722 return resultobj;
5723 fail:
5724 return NULL;
5725 }
5726
5727
5728 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729 PyObject *obj;
5730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5731 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5732 return SWIG_Py_Void();
5733 }
5734
5735 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5736 return SWIG_Python_InitShadowInstance(args);
5737 }
5738
5739 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5740 PyObject *resultobj = 0;
5741 wxPoint *arg1 = (wxPoint *) 0 ;
5742 int arg2 ;
5743 void *argp1 = 0 ;
5744 int res1 = 0 ;
5745 int val2 ;
5746 int ecode2 = 0 ;
5747 PyObject *swig_obj[2] ;
5748
5749 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5756 if (!SWIG_IsOK(ecode2)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5758 }
5759 arg2 = static_cast< int >(val2);
5760 if (arg1) (arg1)->x = arg2;
5761
5762 resultobj = SWIG_Py_Void();
5763 return resultobj;
5764 fail:
5765 return NULL;
5766 }
5767
5768
5769 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5770 PyObject *resultobj = 0;
5771 wxPoint *arg1 = (wxPoint *) 0 ;
5772 int result;
5773 void *argp1 = 0 ;
5774 int res1 = 0 ;
5775 PyObject *swig_obj[1] ;
5776
5777 if (!args) SWIG_fail;
5778 swig_obj[0] = args;
5779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 result = (int) ((arg1)->x);
5785 resultobj = SWIG_From_int(static_cast< int >(result));
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5793 PyObject *resultobj = 0;
5794 wxPoint *arg1 = (wxPoint *) 0 ;
5795 int arg2 ;
5796 void *argp1 = 0 ;
5797 int res1 = 0 ;
5798 int val2 ;
5799 int ecode2 = 0 ;
5800 PyObject *swig_obj[2] ;
5801
5802 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5804 if (!SWIG_IsOK(res1)) {
5805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5806 }
5807 arg1 = reinterpret_cast< wxPoint * >(argp1);
5808 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5809 if (!SWIG_IsOK(ecode2)) {
5810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5811 }
5812 arg2 = static_cast< int >(val2);
5813 if (arg1) (arg1)->y = arg2;
5814
5815 resultobj = SWIG_Py_Void();
5816 return resultobj;
5817 fail:
5818 return NULL;
5819 }
5820
5821
5822 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5823 PyObject *resultobj = 0;
5824 wxPoint *arg1 = (wxPoint *) 0 ;
5825 int result;
5826 void *argp1 = 0 ;
5827 int res1 = 0 ;
5828 PyObject *swig_obj[1] ;
5829
5830 if (!args) SWIG_fail;
5831 swig_obj[0] = args;
5832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 result = (int) ((arg1)->y);
5838 resultobj = SWIG_From_int(static_cast< int >(result));
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj = 0;
5847 int arg1 = (int) 0 ;
5848 int arg2 = (int) 0 ;
5849 wxPoint *result = 0 ;
5850 int val1 ;
5851 int ecode1 = 0 ;
5852 int val2 ;
5853 int ecode2 = 0 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "x",(char *) "y", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5861 if (obj0) {
5862 ecode1 = SWIG_AsVal_int(obj0, &val1);
5863 if (!SWIG_IsOK(ecode1)) {
5864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5865 }
5866 arg1 = static_cast< int >(val1);
5867 }
5868 if (obj1) {
5869 ecode2 = SWIG_AsVal_int(obj1, &val2);
5870 if (!SWIG_IsOK(ecode2)) {
5871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5872 }
5873 arg2 = static_cast< int >(val2);
5874 }
5875 {
5876 result = (wxPoint *)new wxPoint(arg1,arg2);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5887 PyObject *resultobj = 0;
5888 wxPoint *arg1 = (wxPoint *) 0 ;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 PyObject *swig_obj[1] ;
5892
5893 if (!args) SWIG_fail;
5894 swig_obj[0] = args;
5895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5896 if (!SWIG_IsOK(res1)) {
5897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5898 }
5899 arg1 = reinterpret_cast< wxPoint * >(argp1);
5900 {
5901 delete arg1;
5902
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 resultobj = SWIG_Py_Void();
5906 return resultobj;
5907 fail:
5908 return NULL;
5909 }
5910
5911
5912 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5913 PyObject *resultobj = 0;
5914 wxPoint *arg1 = (wxPoint *) 0 ;
5915 PyObject *arg2 = (PyObject *) 0 ;
5916 bool result;
5917 void *argp1 = 0 ;
5918 int res1 = 0 ;
5919 PyObject * obj0 = 0 ;
5920 PyObject * obj1 = 0 ;
5921 char * kwnames[] = {
5922 (char *) "self",(char *) "other", NULL
5923 };
5924
5925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5927 if (!SWIG_IsOK(res1)) {
5928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5929 }
5930 arg1 = reinterpret_cast< wxPoint * >(argp1);
5931 arg2 = obj1;
5932 {
5933 result = (bool)wxPoint___eq__(arg1,arg2);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 {
5937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5938 }
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 PyObject *arg2 = (PyObject *) 0 ;
5949 bool result;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 char * kwnames[] = {
5955 (char *) "self",(char *) "other", NULL
5956 };
5957
5958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5960 if (!SWIG_IsOK(res1)) {
5961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5962 }
5963 arg1 = reinterpret_cast< wxPoint * >(argp1);
5964 arg2 = obj1;
5965 {
5966 result = (bool)wxPoint___ne__(arg1,arg2);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 {
5970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5971 }
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj = 0;
5980 wxPoint *arg1 = (wxPoint *) 0 ;
5981 wxPoint *arg2 = 0 ;
5982 wxPoint result;
5983 void *argp1 = 0 ;
5984 int res1 = 0 ;
5985 wxPoint temp2 ;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "self",(char *) "pt", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5994 if (!SWIG_IsOK(res1)) {
5995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5996 }
5997 arg1 = reinterpret_cast< wxPoint * >(argp1);
5998 {
5999 arg2 = &temp2;
6000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6001 }
6002 {
6003 result = (arg1)->operator +((wxPoint const &)*arg2);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj = 0;
6015 wxPoint *arg1 = (wxPoint *) 0 ;
6016 wxPoint *arg2 = 0 ;
6017 wxPoint result;
6018 void *argp1 = 0 ;
6019 int res1 = 0 ;
6020 wxPoint temp2 ;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 char * kwnames[] = {
6024 (char *) "self",(char *) "pt", NULL
6025 };
6026
6027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6029 if (!SWIG_IsOK(res1)) {
6030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6031 }
6032 arg1 = reinterpret_cast< wxPoint * >(argp1);
6033 {
6034 arg2 = &temp2;
6035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6036 }
6037 {
6038 result = (arg1)->operator -((wxPoint const &)*arg2);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 wxPoint *arg2 = 0 ;
6052 wxPoint *result = 0 ;
6053 void *argp1 = 0 ;
6054 int res1 = 0 ;
6055 wxPoint temp2 ;
6056 PyObject * obj0 = 0 ;
6057 PyObject * obj1 = 0 ;
6058 char * kwnames[] = {
6059 (char *) "self",(char *) "pt", NULL
6060 };
6061
6062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6064 if (!SWIG_IsOK(res1)) {
6065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6066 }
6067 arg1 = reinterpret_cast< wxPoint * >(argp1);
6068 {
6069 arg2 = &temp2;
6070 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6071 }
6072 {
6073 {
6074 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6075 result = (wxPoint *) &_result_ref;
6076 }
6077 if (PyErr_Occurred()) SWIG_fail;
6078 }
6079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6080 return resultobj;
6081 fail:
6082 return NULL;
6083 }
6084
6085
6086 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 wxPoint *arg1 = (wxPoint *) 0 ;
6089 wxPoint *arg2 = 0 ;
6090 wxPoint *result = 0 ;
6091 void *argp1 = 0 ;
6092 int res1 = 0 ;
6093 wxPoint temp2 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 char * kwnames[] = {
6097 (char *) "self",(char *) "pt", NULL
6098 };
6099
6100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6102 if (!SWIG_IsOK(res1)) {
6103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6104 }
6105 arg1 = reinterpret_cast< wxPoint * >(argp1);
6106 {
6107 arg2 = &temp2;
6108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6109 }
6110 {
6111 {
6112 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6113 result = (wxPoint *) &_result_ref;
6114 }
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6118 return resultobj;
6119 fail:
6120 return NULL;
6121 }
6122
6123
6124 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj = 0;
6126 wxPoint *arg1 = (wxPoint *) 0 ;
6127 long arg2 ;
6128 long arg3 ;
6129 void *argp1 = 0 ;
6130 int res1 = 0 ;
6131 long val2 ;
6132 int ecode2 = 0 ;
6133 long val3 ;
6134 int ecode3 = 0 ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 PyObject * obj2 = 0 ;
6138 char * kwnames[] = {
6139 (char *) "self",(char *) "x",(char *) "y", NULL
6140 };
6141
6142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6144 if (!SWIG_IsOK(res1)) {
6145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6146 }
6147 arg1 = reinterpret_cast< wxPoint * >(argp1);
6148 ecode2 = SWIG_AsVal_long(obj1, &val2);
6149 if (!SWIG_IsOK(ecode2)) {
6150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6151 }
6152 arg2 = static_cast< long >(val2);
6153 ecode3 = SWIG_AsVal_long(obj2, &val3);
6154 if (!SWIG_IsOK(ecode3)) {
6155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6156 }
6157 arg3 = static_cast< long >(val3);
6158 {
6159 wxPoint_Set(arg1,arg2,arg3);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_Py_Void();
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *resultobj = 0;
6171 wxPoint *arg1 = (wxPoint *) 0 ;
6172 PyObject *result = 0 ;
6173 void *argp1 = 0 ;
6174 int res1 = 0 ;
6175 PyObject *swig_obj[1] ;
6176
6177 if (!args) SWIG_fail;
6178 swig_obj[0] = args;
6179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6180 if (!SWIG_IsOK(res1)) {
6181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6182 }
6183 arg1 = reinterpret_cast< wxPoint * >(argp1);
6184 {
6185 result = (PyObject *)wxPoint_Get(arg1);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 resultobj = result;
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196 PyObject *obj;
6197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6198 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6199 return SWIG_Py_Void();
6200 }
6201
6202 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6203 return SWIG_Python_InitShadowInstance(args);
6204 }
6205
6206 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 int arg1 = (int) 0 ;
6209 int arg2 = (int) 0 ;
6210 int arg3 = (int) 0 ;
6211 int arg4 = (int) 0 ;
6212 wxRect *result = 0 ;
6213 int val1 ;
6214 int ecode1 = 0 ;
6215 int val2 ;
6216 int ecode2 = 0 ;
6217 int val3 ;
6218 int ecode3 = 0 ;
6219 int val4 ;
6220 int ecode4 = 0 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 PyObject * obj2 = 0 ;
6224 PyObject * obj3 = 0 ;
6225 char * kwnames[] = {
6226 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6227 };
6228
6229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6230 if (obj0) {
6231 ecode1 = SWIG_AsVal_int(obj0, &val1);
6232 if (!SWIG_IsOK(ecode1)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6234 }
6235 arg1 = static_cast< int >(val1);
6236 }
6237 if (obj1) {
6238 ecode2 = SWIG_AsVal_int(obj1, &val2);
6239 if (!SWIG_IsOK(ecode2)) {
6240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6241 }
6242 arg2 = static_cast< int >(val2);
6243 }
6244 if (obj2) {
6245 ecode3 = SWIG_AsVal_int(obj2, &val3);
6246 if (!SWIG_IsOK(ecode3)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6248 }
6249 arg3 = static_cast< int >(val3);
6250 }
6251 if (obj3) {
6252 ecode4 = SWIG_AsVal_int(obj3, &val4);
6253 if (!SWIG_IsOK(ecode4)) {
6254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6255 }
6256 arg4 = static_cast< int >(val4);
6257 }
6258 {
6259 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxPoint *arg1 = 0 ;
6272 wxPoint *arg2 = 0 ;
6273 wxRect *result = 0 ;
6274 wxPoint temp1 ;
6275 wxPoint temp2 ;
6276 PyObject * obj0 = 0 ;
6277 PyObject * obj1 = 0 ;
6278 char * kwnames[] = {
6279 (char *) "topLeft",(char *) "bottomRight", NULL
6280 };
6281
6282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6283 {
6284 arg1 = &temp1;
6285 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6286 }
6287 {
6288 arg2 = &temp2;
6289 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6290 }
6291 {
6292 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxPoint *arg1 = 0 ;
6305 wxSize *arg2 = 0 ;
6306 wxRect *result = 0 ;
6307 wxPoint temp1 ;
6308 wxSize temp2 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "pos",(char *) "size", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6316 {
6317 arg1 = &temp1;
6318 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6319 }
6320 {
6321 arg2 = &temp2;
6322 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6323 }
6324 {
6325 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = 0;
6337 wxSize *arg1 = 0 ;
6338 wxRect *result = 0 ;
6339 wxSize temp1 ;
6340 PyObject * obj0 = 0 ;
6341 char * kwnames[] = {
6342 (char *) "size", NULL
6343 };
6344
6345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6346 {
6347 arg1 = &temp1;
6348 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6349 }
6350 {
6351 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6362 PyObject *resultobj = 0;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 void *argp1 = 0 ;
6365 int res1 = 0 ;
6366 PyObject *swig_obj[1] ;
6367
6368 if (!args) SWIG_fail;
6369 swig_obj[0] = args;
6370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6371 if (!SWIG_IsOK(res1)) {
6372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6373 }
6374 arg1 = reinterpret_cast< wxRect * >(argp1);
6375 {
6376 delete arg1;
6377
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 resultobj = SWIG_Py_Void();
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6388 PyObject *resultobj = 0;
6389 wxRect *arg1 = (wxRect *) 0 ;
6390 int result;
6391 void *argp1 = 0 ;
6392 int res1 = 0 ;
6393 PyObject *swig_obj[1] ;
6394
6395 if (!args) SWIG_fail;
6396 swig_obj[0] = args;
6397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6398 if (!SWIG_IsOK(res1)) {
6399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6400 }
6401 arg1 = reinterpret_cast< wxRect * >(argp1);
6402 {
6403 result = (int)((wxRect const *)arg1)->GetX();
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 resultobj = SWIG_From_int(static_cast< int >(result));
6407 return resultobj;
6408 fail:
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxRect *arg1 = (wxRect *) 0 ;
6416 int arg2 ;
6417 void *argp1 = 0 ;
6418 int res1 = 0 ;
6419 int val2 ;
6420 int ecode2 = 0 ;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "self",(char *) "x", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6429 if (!SWIG_IsOK(res1)) {
6430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6431 }
6432 arg1 = reinterpret_cast< wxRect * >(argp1);
6433 ecode2 = SWIG_AsVal_int(obj1, &val2);
6434 if (!SWIG_IsOK(ecode2)) {
6435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6436 }
6437 arg2 = static_cast< int >(val2);
6438 {
6439 (arg1)->SetX(arg2);
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 resultobj = SWIG_Py_Void();
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6450 PyObject *resultobj = 0;
6451 wxRect *arg1 = (wxRect *) 0 ;
6452 int result;
6453 void *argp1 = 0 ;
6454 int res1 = 0 ;
6455 PyObject *swig_obj[1] ;
6456
6457 if (!args) SWIG_fail;
6458 swig_obj[0] = args;
6459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6460 if (!SWIG_IsOK(res1)) {
6461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6462 }
6463 arg1 = reinterpret_cast< wxRect * >(argp1);
6464 {
6465 result = (int)(arg1)->GetY();
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_From_int(static_cast< int >(result));
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int arg2 ;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 int val2 ;
6482 int ecode2 = 0 ;
6483 PyObject * obj0 = 0 ;
6484 PyObject * obj1 = 0 ;
6485 char * kwnames[] = {
6486 (char *) "self",(char *) "y", NULL
6487 };
6488
6489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6491 if (!SWIG_IsOK(res1)) {
6492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6493 }
6494 arg1 = reinterpret_cast< wxRect * >(argp1);
6495 ecode2 = SWIG_AsVal_int(obj1, &val2);
6496 if (!SWIG_IsOK(ecode2)) {
6497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6498 }
6499 arg2 = static_cast< int >(val2);
6500 {
6501 (arg1)->SetY(arg2);
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 resultobj = SWIG_Py_Void();
6505 return resultobj;
6506 fail:
6507 return NULL;
6508 }
6509
6510
6511 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6512 PyObject *resultobj = 0;
6513 wxRect *arg1 = (wxRect *) 0 ;
6514 int result;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 PyObject *swig_obj[1] ;
6518
6519 if (!args) SWIG_fail;
6520 swig_obj[0] = args;
6521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6522 if (!SWIG_IsOK(res1)) {
6523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6524 }
6525 arg1 = reinterpret_cast< wxRect * >(argp1);
6526 {
6527 result = (int)((wxRect const *)arg1)->GetWidth();
6528 if (PyErr_Occurred()) SWIG_fail;
6529 }
6530 resultobj = SWIG_From_int(static_cast< int >(result));
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj = 0;
6539 wxRect *arg1 = (wxRect *) 0 ;
6540 int arg2 ;
6541 void *argp1 = 0 ;
6542 int res1 = 0 ;
6543 int val2 ;
6544 int ecode2 = 0 ;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 char * kwnames[] = {
6548 (char *) "self",(char *) "w", NULL
6549 };
6550
6551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 ecode2 = SWIG_AsVal_int(obj1, &val2);
6558 if (!SWIG_IsOK(ecode2)) {
6559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6560 }
6561 arg2 = static_cast< int >(val2);
6562 {
6563 (arg1)->SetWidth(arg2);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_Py_Void();
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6574 PyObject *resultobj = 0;
6575 wxRect *arg1 = (wxRect *) 0 ;
6576 int result;
6577 void *argp1 = 0 ;
6578 int res1 = 0 ;
6579 PyObject *swig_obj[1] ;
6580
6581 if (!args) SWIG_fail;
6582 swig_obj[0] = args;
6583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
6589 result = (int)((wxRect const *)arg1)->GetHeight();
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_From_int(static_cast< int >(result));
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 int arg2 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 int val2 ;
6606 int ecode2 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 char * kwnames[] = {
6610 (char *) "self",(char *) "h", NULL
6611 };
6612
6613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 ecode2 = SWIG_AsVal_int(obj1, &val2);
6620 if (!SWIG_IsOK(ecode2)) {
6621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6622 }
6623 arg2 = static_cast< int >(val2);
6624 {
6625 (arg1)->SetHeight(arg2);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_Py_Void();
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 wxPoint result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxRect * >(argp1);
6650 {
6651 result = ((wxRect const *)arg1)->GetPosition();
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj = 0;
6663 wxRect *arg1 = (wxRect *) 0 ;
6664 wxPoint *arg2 = 0 ;
6665 void *argp1 = 0 ;
6666 int res1 = 0 ;
6667 wxPoint temp2 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 char * kwnames[] = {
6671 (char *) "self",(char *) "p", NULL
6672 };
6673
6674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6678 }
6679 arg1 = reinterpret_cast< wxRect * >(argp1);
6680 {
6681 arg2 = &temp2;
6682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6683 }
6684 {
6685 (arg1)->SetPosition((wxPoint const &)*arg2);
6686 if (PyErr_Occurred()) SWIG_fail;
6687 }
6688 resultobj = SWIG_Py_Void();
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6696 PyObject *resultobj = 0;
6697 wxRect *arg1 = (wxRect *) 0 ;
6698 wxSize result;
6699 void *argp1 = 0 ;
6700 int res1 = 0 ;
6701 PyObject *swig_obj[1] ;
6702
6703 if (!args) SWIG_fail;
6704 swig_obj[0] = args;
6705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6706 if (!SWIG_IsOK(res1)) {
6707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6708 }
6709 arg1 = reinterpret_cast< wxRect * >(argp1);
6710 {
6711 result = ((wxRect const *)arg1)->GetSize();
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = 0;
6723 wxRect *arg1 = (wxRect *) 0 ;
6724 wxSize *arg2 = 0 ;
6725 void *argp1 = 0 ;
6726 int res1 = 0 ;
6727 wxSize temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char * kwnames[] = {
6731 (char *) "self",(char *) "s", NULL
6732 };
6733
6734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6736 if (!SWIG_IsOK(res1)) {
6737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6738 }
6739 arg1 = reinterpret_cast< wxRect * >(argp1);
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 (arg1)->SetSize((wxSize const &)*arg2);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 resultobj = SWIG_Py_Void();
6749 return resultobj;
6750 fail:
6751 return NULL;
6752 }
6753
6754
6755 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6756 PyObject *resultobj = 0;
6757 wxRect *arg1 = (wxRect *) 0 ;
6758 bool result;
6759 void *argp1 = 0 ;
6760 int res1 = 0 ;
6761 PyObject *swig_obj[1] ;
6762
6763 if (!args) SWIG_fail;
6764 swig_obj[0] = args;
6765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6766 if (!SWIG_IsOK(res1)) {
6767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6768 }
6769 arg1 = reinterpret_cast< wxRect * >(argp1);
6770 {
6771 result = (bool)((wxRect const *)arg1)->IsEmpty();
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 wxRect *arg1 = (wxRect *) 0 ;
6786 wxPoint result;
6787 void *argp1 = 0 ;
6788 int res1 = 0 ;
6789 PyObject *swig_obj[1] ;
6790
6791 if (!args) SWIG_fail;
6792 swig_obj[0] = args;
6793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6794 if (!SWIG_IsOK(res1)) {
6795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6796 }
6797 arg1 = reinterpret_cast< wxRect * >(argp1);
6798 {
6799 result = ((wxRect const *)arg1)->GetTopLeft();
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 wxPoint *arg2 = 0 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 wxPoint temp2 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char * kwnames[] = {
6819 (char *) "self",(char *) "p", NULL
6820 };
6821
6822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6824 if (!SWIG_IsOK(res1)) {
6825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6826 }
6827 arg1 = reinterpret_cast< wxRect * >(argp1);
6828 {
6829 arg2 = &temp2;
6830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6831 }
6832 {
6833 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 return resultobj;
6838 fail:
6839 return NULL;
6840 }
6841
6842
6843 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6844 PyObject *resultobj = 0;
6845 wxRect *arg1 = (wxRect *) 0 ;
6846 wxPoint result;
6847 void *argp1 = 0 ;
6848 int res1 = 0 ;
6849 PyObject *swig_obj[1] ;
6850
6851 if (!args) SWIG_fail;
6852 swig_obj[0] = args;
6853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6854 if (!SWIG_IsOK(res1)) {
6855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6856 }
6857 arg1 = reinterpret_cast< wxRect * >(argp1);
6858 {
6859 result = ((wxRect const *)arg1)->GetBottomRight();
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 wxPoint *arg2 = 0 ;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 wxPoint temp2 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char * kwnames[] = {
6879 (char *) "self",(char *) "p", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6884 if (!SWIG_IsOK(res1)) {
6885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6886 }
6887 arg1 = reinterpret_cast< wxRect * >(argp1);
6888 {
6889 arg2 = &temp2;
6890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6891 }
6892 {
6893 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_Py_Void();
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 wxRect *arg1 = (wxRect *) 0 ;
6906 wxPoint result;
6907 void *argp1 = 0 ;
6908 int res1 = 0 ;
6909 PyObject *swig_obj[1] ;
6910
6911 if (!args) SWIG_fail;
6912 swig_obj[0] = args;
6913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6914 if (!SWIG_IsOK(res1)) {
6915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6916 }
6917 arg1 = reinterpret_cast< wxRect * >(argp1);
6918 {
6919 result = ((wxRect const *)arg1)->GetTopRight();
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxRect *arg1 = (wxRect *) 0 ;
6932 wxPoint *arg2 = 0 ;
6933 void *argp1 = 0 ;
6934 int res1 = 0 ;
6935 wxPoint temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "self",(char *) "p", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6946 }
6947 arg1 = reinterpret_cast< wxRect * >(argp1);
6948 {
6949 arg2 = &temp2;
6950 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6951 }
6952 {
6953 (arg1)->SetTopRight((wxPoint const &)*arg2);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_Py_Void();
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6964 PyObject *resultobj = 0;
6965 wxRect *arg1 = (wxRect *) 0 ;
6966 wxPoint result;
6967 void *argp1 = 0 ;
6968 int res1 = 0 ;
6969 PyObject *swig_obj[1] ;
6970
6971 if (!args) SWIG_fail;
6972 swig_obj[0] = args;
6973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 {
6979 result = ((wxRect const *)arg1)->GetBottomLeft();
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj = 0;
6991 wxRect *arg1 = (wxRect *) 0 ;
6992 wxPoint *arg2 = 0 ;
6993 void *argp1 = 0 ;
6994 int res1 = 0 ;
6995 wxPoint temp2 ;
6996 PyObject * obj0 = 0 ;
6997 PyObject * obj1 = 0 ;
6998 char * kwnames[] = {
6999 (char *) "self",(char *) "p", NULL
7000 };
7001
7002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7004 if (!SWIG_IsOK(res1)) {
7005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7006 }
7007 arg1 = reinterpret_cast< wxRect * >(argp1);
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_Py_Void();
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7024 PyObject *resultobj = 0;
7025 wxRect *arg1 = (wxRect *) 0 ;
7026 int result;
7027 void *argp1 = 0 ;
7028 int res1 = 0 ;
7029 PyObject *swig_obj[1] ;
7030
7031 if (!args) SWIG_fail;
7032 swig_obj[0] = args;
7033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7036 }
7037 arg1 = reinterpret_cast< wxRect * >(argp1);
7038 {
7039 result = (int)((wxRect const *)arg1)->GetLeft();
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_From_int(static_cast< int >(result));
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 wxRect *arg1 = (wxRect *) 0 ;
7052 int result;
7053 void *argp1 = 0 ;
7054 int res1 = 0 ;
7055 PyObject *swig_obj[1] ;
7056
7057 if (!args) SWIG_fail;
7058 swig_obj[0] = args;
7059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7060 if (!SWIG_IsOK(res1)) {
7061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7062 }
7063 arg1 = reinterpret_cast< wxRect * >(argp1);
7064 {
7065 result = (int)((wxRect const *)arg1)->GetTop();
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_From_int(static_cast< int >(result));
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7076 PyObject *resultobj = 0;
7077 wxRect *arg1 = (wxRect *) 0 ;
7078 int result;
7079 void *argp1 = 0 ;
7080 int res1 = 0 ;
7081 PyObject *swig_obj[1] ;
7082
7083 if (!args) SWIG_fail;
7084 swig_obj[0] = args;
7085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 {
7091 result = (int)((wxRect const *)arg1)->GetBottom();
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_From_int(static_cast< int >(result));
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7102 PyObject *resultobj = 0;
7103 wxRect *arg1 = (wxRect *) 0 ;
7104 int result;
7105 void *argp1 = 0 ;
7106 int res1 = 0 ;
7107 PyObject *swig_obj[1] ;
7108
7109 if (!args) SWIG_fail;
7110 swig_obj[0] = args;
7111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 {
7117 result = (int)((wxRect const *)arg1)->GetRight();
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_From_int(static_cast< int >(result));
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 int val2 ;
7134 int ecode2 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "left", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7145 }
7146 arg1 = reinterpret_cast< wxRect * >(argp1);
7147 ecode2 = SWIG_AsVal_int(obj1, &val2);
7148 if (!SWIG_IsOK(ecode2)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7150 }
7151 arg2 = static_cast< int >(val2);
7152 {
7153 (arg1)->SetLeft(arg2);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_Py_Void();
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 int arg2 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 int val2 ;
7170 int ecode2 = 0 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "right", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 {
7189 (arg1)->SetRight(arg2);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_Py_Void();
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 int arg2 ;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 int val2 ;
7206 int ecode2 = 0 ;
7207 PyObject * obj0 = 0 ;
7208 PyObject * obj1 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "top", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 ecode2 = SWIG_AsVal_int(obj1, &val2);
7220 if (!SWIG_IsOK(ecode2)) {
7221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7222 }
7223 arg2 = static_cast< int >(val2);
7224 {
7225 (arg1)->SetTop(arg2);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 resultobj = SWIG_Py_Void();
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxRect *arg1 = (wxRect *) 0 ;
7238 int arg2 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 int val2 ;
7242 int ecode2 = 0 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char * kwnames[] = {
7246 (char *) "self",(char *) "bottom", NULL
7247 };
7248
7249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7251 if (!SWIG_IsOK(res1)) {
7252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7253 }
7254 arg1 = reinterpret_cast< wxRect * >(argp1);
7255 ecode2 = SWIG_AsVal_int(obj1, &val2);
7256 if (!SWIG_IsOK(ecode2)) {
7257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7258 }
7259 arg2 = static_cast< int >(val2);
7260 {
7261 (arg1)->SetBottom(arg2);
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = SWIG_Py_Void();
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7272 PyObject *resultobj = 0;
7273 wxRect *arg1 = (wxRect *) 0 ;
7274 int arg2 ;
7275 int arg3 ;
7276 wxRect *result = 0 ;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 int val2 ;
7280 int ecode2 = 0 ;
7281 int val3 ;
7282 int ecode3 = 0 ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 PyObject * obj2 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "dx",(char *) "dy", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 ecode2 = SWIG_AsVal_int(obj1, &val2);
7297 if (!SWIG_IsOK(ecode2)) {
7298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7299 }
7300 arg2 = static_cast< int >(val2);
7301 ecode3 = SWIG_AsVal_int(obj2, &val3);
7302 if (!SWIG_IsOK(ecode3)) {
7303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7304 }
7305 arg3 = static_cast< int >(val3);
7306 {
7307 {
7308 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7309 result = (wxRect *) &_result_ref;
7310 }
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 int arg2 ;
7324 int arg3 ;
7325 wxRect *result = 0 ;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 int val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "dx",(char *) "dy", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7343 }
7344 arg1 = reinterpret_cast< wxRect * >(argp1);
7345 ecode2 = SWIG_AsVal_int(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7348 }
7349 arg2 = static_cast< int >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
7356 {
7357 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7358 result = (wxRect *) &_result_ref;
7359 }
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 int arg2 ;
7373 int arg3 ;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 int val2 ;
7377 int ecode2 = 0 ;
7378 int val3 ;
7379 int ecode3 = 0 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 PyObject * obj2 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "dx",(char *) "dy", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 ecode2 = SWIG_AsVal_int(obj1, &val2);
7394 if (!SWIG_IsOK(ecode2)) {
7395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7396 }
7397 arg2 = static_cast< int >(val2);
7398 ecode3 = SWIG_AsVal_int(obj2, &val3);
7399 if (!SWIG_IsOK(ecode3)) {
7400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7401 }
7402 arg3 = static_cast< int >(val3);
7403 {
7404 (arg1)->Offset(arg2,arg3);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_Py_Void();
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7415 PyObject *resultobj = 0;
7416 wxRect *arg1 = (wxRect *) 0 ;
7417 wxPoint *arg2 = 0 ;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 wxPoint temp2 ;
7421 PyObject * obj0 = 0 ;
7422 PyObject * obj1 = 0 ;
7423 char * kwnames[] = {
7424 (char *) "self",(char *) "pt", NULL
7425 };
7426
7427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7429 if (!SWIG_IsOK(res1)) {
7430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7431 }
7432 arg1 = reinterpret_cast< wxRect * >(argp1);
7433 {
7434 arg2 = &temp2;
7435 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7436 }
7437 {
7438 (arg1)->Offset((wxPoint const &)*arg2);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 resultobj = SWIG_Py_Void();
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxRect *arg2 = 0 ;
7452 wxRect result;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxRect temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "rect", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 result = (arg1)->Intersect((wxRect const &)*arg2);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj = 0;
7485 wxRect *arg1 = (wxRect *) 0 ;
7486 wxRect *arg2 = 0 ;
7487 wxRect result;
7488 void *argp1 = 0 ;
7489 int res1 = 0 ;
7490 wxRect temp2 ;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "rect", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 {
7504 arg2 = &temp2;
7505 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7506 }
7507 {
7508 result = (arg1)->Union((wxRect const &)*arg2);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7519 PyObject *resultobj = 0;
7520 wxRect *arg1 = (wxRect *) 0 ;
7521 wxRect *arg2 = 0 ;
7522 wxRect result;
7523 void *argp1 = 0 ;
7524 int res1 = 0 ;
7525 wxRect temp2 ;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char * kwnames[] = {
7529 (char *) "self",(char *) "rect", NULL
7530 };
7531
7532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7534 if (!SWIG_IsOK(res1)) {
7535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7536 }
7537 arg1 = reinterpret_cast< wxRect * >(argp1);
7538 {
7539 arg2 = &temp2;
7540 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7541 }
7542 {
7543 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj = 0;
7555 wxRect *arg1 = (wxRect *) 0 ;
7556 wxRect *arg2 = 0 ;
7557 wxRect *result = 0 ;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 wxRect temp2 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 char * kwnames[] = {
7564 (char *) "self",(char *) "rect", NULL
7565 };
7566
7567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7569 if (!SWIG_IsOK(res1)) {
7570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7571 }
7572 arg1 = reinterpret_cast< wxRect * >(argp1);
7573 {
7574 arg2 = &temp2;
7575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7576 }
7577 {
7578 {
7579 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7580 result = (wxRect *) &_result_ref;
7581 }
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj = 0;
7593 wxRect *arg1 = (wxRect *) 0 ;
7594 PyObject *arg2 = (PyObject *) 0 ;
7595 bool result;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "other", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7608 }
7609 arg1 = reinterpret_cast< wxRect * >(argp1);
7610 arg2 = obj1;
7611 {
7612 result = (bool)wxRect___eq__(arg1,arg2);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7617 }
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj = 0;
7626 wxRect *arg1 = (wxRect *) 0 ;
7627 PyObject *arg2 = (PyObject *) 0 ;
7628 bool result;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
7631 PyObject * obj0 = 0 ;
7632 PyObject * obj1 = 0 ;
7633 char * kwnames[] = {
7634 (char *) "self",(char *) "other", NULL
7635 };
7636
7637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 arg2 = obj1;
7644 {
7645 result = (bool)wxRect___ne__(arg1,arg2);
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 {
7649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7650 }
7651 return resultobj;
7652 fail:
7653 return NULL;
7654 }
7655
7656
7657 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7658 PyObject *resultobj = 0;
7659 wxRect *arg1 = (wxRect *) 0 ;
7660 int arg2 ;
7661 int arg3 ;
7662 bool result;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 int val2 ;
7666 int ecode2 = 0 ;
7667 int val3 ;
7668 int ecode3 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 PyObject * obj2 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "x",(char *) "y", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7680 }
7681 arg1 = reinterpret_cast< wxRect * >(argp1);
7682 ecode2 = SWIG_AsVal_int(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7685 }
7686 arg2 = static_cast< int >(val2);
7687 ecode3 = SWIG_AsVal_int(obj2, &val3);
7688 if (!SWIG_IsOK(ecode3)) {
7689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7690 }
7691 arg3 = static_cast< int >(val3);
7692 {
7693 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj = 0;
7707 wxRect *arg1 = (wxRect *) 0 ;
7708 wxPoint *arg2 = 0 ;
7709 bool result;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 wxPoint temp2 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "pt", NULL
7717 };
7718
7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 {
7726 arg2 = &temp2;
7727 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7728 }
7729 {
7730 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 {
7734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7735 }
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxRect *arg1 = (wxRect *) 0 ;
7745 wxRect *arg2 = 0 ;
7746 bool result;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 wxRect temp2 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "rect", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 {
7763 arg2 = &temp2;
7764 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7765 }
7766 {
7767 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj = 0;
7781 wxRect *arg1 = (wxRect *) 0 ;
7782 wxRect *arg2 = 0 ;
7783 bool result;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 wxRect temp2 ;
7787 PyObject * obj0 = 0 ;
7788 PyObject * obj1 = 0 ;
7789 char * kwnames[] = {
7790 (char *) "self",(char *) "rect", NULL
7791 };
7792
7793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7795 if (!SWIG_IsOK(res1)) {
7796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7797 }
7798 arg1 = reinterpret_cast< wxRect * >(argp1);
7799 {
7800 arg2 = &temp2;
7801 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7802 }
7803 {
7804 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj = 0;
7818 wxRect *arg1 = (wxRect *) 0 ;
7819 wxRect *arg2 = 0 ;
7820 int arg3 = (int) wxBOTH ;
7821 wxRect result;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 wxRect temp2 ;
7825 int val3 ;
7826 int ecode3 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 PyObject * obj2 = 0 ;
7830 char * kwnames[] = {
7831 (char *) "self",(char *) "r",(char *) "dir", NULL
7832 };
7833
7834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7836 if (!SWIG_IsOK(res1)) {
7837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7838 }
7839 arg1 = reinterpret_cast< wxRect * >(argp1);
7840 {
7841 arg2 = &temp2;
7842 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7843 }
7844 if (obj2) {
7845 ecode3 = SWIG_AsVal_int(obj2, &val3);
7846 if (!SWIG_IsOK(ecode3)) {
7847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7848 }
7849 arg3 = static_cast< int >(val3);
7850 }
7851 {
7852 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 int arg2 ;
7866 void *argp1 = 0 ;
7867 int res1 = 0 ;
7868 int val2 ;
7869 int ecode2 = 0 ;
7870 PyObject *swig_obj[2] ;
7871
7872 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7876 }
7877 arg1 = reinterpret_cast< wxRect * >(argp1);
7878 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7879 if (!SWIG_IsOK(ecode2)) {
7880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7881 }
7882 arg2 = static_cast< int >(val2);
7883 if (arg1) (arg1)->x = arg2;
7884
7885 resultobj = SWIG_Py_Void();
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7893 PyObject *resultobj = 0;
7894 wxRect *arg1 = (wxRect *) 0 ;
7895 int result;
7896 void *argp1 = 0 ;
7897 int res1 = 0 ;
7898 PyObject *swig_obj[1] ;
7899
7900 if (!args) SWIG_fail;
7901 swig_obj[0] = args;
7902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7905 }
7906 arg1 = reinterpret_cast< wxRect * >(argp1);
7907 result = (int) ((arg1)->x);
7908 resultobj = SWIG_From_int(static_cast< int >(result));
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 wxRect *arg1 = (wxRect *) 0 ;
7918 int arg2 ;
7919 void *argp1 = 0 ;
7920 int res1 = 0 ;
7921 int val2 ;
7922 int ecode2 = 0 ;
7923 PyObject *swig_obj[2] ;
7924
7925 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7927 if (!SWIG_IsOK(res1)) {
7928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7929 }
7930 arg1 = reinterpret_cast< wxRect * >(argp1);
7931 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7932 if (!SWIG_IsOK(ecode2)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7934 }
7935 arg2 = static_cast< int >(val2);
7936 if (arg1) (arg1)->y = arg2;
7937
7938 resultobj = SWIG_Py_Void();
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7946 PyObject *resultobj = 0;
7947 wxRect *arg1 = (wxRect *) 0 ;
7948 int result;
7949 void *argp1 = 0 ;
7950 int res1 = 0 ;
7951 PyObject *swig_obj[1] ;
7952
7953 if (!args) SWIG_fail;
7954 swig_obj[0] = args;
7955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7958 }
7959 arg1 = reinterpret_cast< wxRect * >(argp1);
7960 result = (int) ((arg1)->y);
7961 resultobj = SWIG_From_int(static_cast< int >(result));
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7969 PyObject *resultobj = 0;
7970 wxRect *arg1 = (wxRect *) 0 ;
7971 int arg2 ;
7972 void *argp1 = 0 ;
7973 int res1 = 0 ;
7974 int val2 ;
7975 int ecode2 = 0 ;
7976 PyObject *swig_obj[2] ;
7977
7978 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7980 if (!SWIG_IsOK(res1)) {
7981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7982 }
7983 arg1 = reinterpret_cast< wxRect * >(argp1);
7984 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7985 if (!SWIG_IsOK(ecode2)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7987 }
7988 arg2 = static_cast< int >(val2);
7989 if (arg1) (arg1)->width = arg2;
7990
7991 resultobj = SWIG_Py_Void();
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7999 PyObject *resultobj = 0;
8000 wxRect *arg1 = (wxRect *) 0 ;
8001 int result;
8002 void *argp1 = 0 ;
8003 int res1 = 0 ;
8004 PyObject *swig_obj[1] ;
8005
8006 if (!args) SWIG_fail;
8007 swig_obj[0] = args;
8008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8009 if (!SWIG_IsOK(res1)) {
8010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8011 }
8012 arg1 = reinterpret_cast< wxRect * >(argp1);
8013 result = (int) ((arg1)->width);
8014 resultobj = SWIG_From_int(static_cast< int >(result));
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxRect *arg1 = (wxRect *) 0 ;
8024 int arg2 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 int val2 ;
8028 int ecode2 = 0 ;
8029 PyObject *swig_obj[2] ;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8033 if (!SWIG_IsOK(res1)) {
8034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8035 }
8036 arg1 = reinterpret_cast< wxRect * >(argp1);
8037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8038 if (!SWIG_IsOK(ecode2)) {
8039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8040 }
8041 arg2 = static_cast< int >(val2);
8042 if (arg1) (arg1)->height = arg2;
8043
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053 wxRect *arg1 = (wxRect *) 0 ;
8054 int result;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 PyObject *swig_obj[1] ;
8058
8059 if (!args) SWIG_fail;
8060 swig_obj[0] = args;
8061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8062 if (!SWIG_IsOK(res1)) {
8063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8064 }
8065 arg1 = reinterpret_cast< wxRect * >(argp1);
8066 result = (int) ((arg1)->height);
8067 resultobj = SWIG_From_int(static_cast< int >(result));
8068 return resultobj;
8069 fail:
8070 return NULL;
8071 }
8072
8073
8074 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8075 PyObject *resultobj = 0;
8076 wxRect *arg1 = (wxRect *) 0 ;
8077 int arg2 = (int) 0 ;
8078 int arg3 = (int) 0 ;
8079 int arg4 = (int) 0 ;
8080 int arg5 = (int) 0 ;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 int val2 ;
8084 int ecode2 = 0 ;
8085 int val3 ;
8086 int ecode3 = 0 ;
8087 int val4 ;
8088 int ecode4 = 0 ;
8089 int val5 ;
8090 int ecode5 = 0 ;
8091 PyObject * obj0 = 0 ;
8092 PyObject * obj1 = 0 ;
8093 PyObject * obj2 = 0 ;
8094 PyObject * obj3 = 0 ;
8095 PyObject * obj4 = 0 ;
8096 char * kwnames[] = {
8097 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8098 };
8099
8100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8104 }
8105 arg1 = reinterpret_cast< wxRect * >(argp1);
8106 if (obj1) {
8107 ecode2 = SWIG_AsVal_int(obj1, &val2);
8108 if (!SWIG_IsOK(ecode2)) {
8109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8110 }
8111 arg2 = static_cast< int >(val2);
8112 }
8113 if (obj2) {
8114 ecode3 = SWIG_AsVal_int(obj2, &val3);
8115 if (!SWIG_IsOK(ecode3)) {
8116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8117 }
8118 arg3 = static_cast< int >(val3);
8119 }
8120 if (obj3) {
8121 ecode4 = SWIG_AsVal_int(obj3, &val4);
8122 if (!SWIG_IsOK(ecode4)) {
8123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8124 }
8125 arg4 = static_cast< int >(val4);
8126 }
8127 if (obj4) {
8128 ecode5 = SWIG_AsVal_int(obj4, &val5);
8129 if (!SWIG_IsOK(ecode5)) {
8130 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8131 }
8132 arg5 = static_cast< int >(val5);
8133 }
8134 {
8135 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 resultobj = SWIG_Py_Void();
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 PyObject *result = 0 ;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 PyObject *swig_obj[1] ;
8152
8153 if (!args) SWIG_fail;
8154 swig_obj[0] = args;
8155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8156 if (!SWIG_IsOK(res1)) {
8157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8158 }
8159 arg1 = reinterpret_cast< wxRect * >(argp1);
8160 {
8161 result = (PyObject *)wxRect_Get(arg1);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = result;
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *obj;
8173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8174 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8175 return SWIG_Py_Void();
8176 }
8177
8178 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8179 return SWIG_Python_InitShadowInstance(args);
8180 }
8181
8182 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj = 0;
8184 wxRect *arg1 = (wxRect *) 0 ;
8185 wxRect *arg2 = (wxRect *) 0 ;
8186 PyObject *result = 0 ;
8187 void *argp1 = 0 ;
8188 int res1 = 0 ;
8189 void *argp2 = 0 ;
8190 int res2 = 0 ;
8191 PyObject * obj0 = 0 ;
8192 PyObject * obj1 = 0 ;
8193 char * kwnames[] = {
8194 (char *) "r1",(char *) "r2", NULL
8195 };
8196
8197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8199 if (!SWIG_IsOK(res1)) {
8200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8201 }
8202 arg1 = reinterpret_cast< wxRect * >(argp1);
8203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8204 if (!SWIG_IsOK(res2)) {
8205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8206 }
8207 arg2 = reinterpret_cast< wxRect * >(argp2);
8208 {
8209 if (!wxPyCheckForApp()) SWIG_fail;
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (PyObject *)wxIntersectRect(arg1,arg2);
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 resultobj = result;
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj = 0;
8224 double arg1 = (double) 0.0 ;
8225 double arg2 = (double) 0.0 ;
8226 wxPoint2D *result = 0 ;
8227 double val1 ;
8228 int ecode1 = 0 ;
8229 double val2 ;
8230 int ecode2 = 0 ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 char * kwnames[] = {
8234 (char *) "x",(char *) "y", NULL
8235 };
8236
8237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8238 if (obj0) {
8239 ecode1 = SWIG_AsVal_double(obj0, &val1);
8240 if (!SWIG_IsOK(ecode1)) {
8241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8242 }
8243 arg1 = static_cast< double >(val1);
8244 }
8245 if (obj1) {
8246 ecode2 = SWIG_AsVal_double(obj1, &val2);
8247 if (!SWIG_IsOK(ecode2)) {
8248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8249 }
8250 arg2 = static_cast< double >(val2);
8251 }
8252 {
8253 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = 0 ;
8266 wxPoint2D *result = 0 ;
8267 wxPoint2D temp1 ;
8268 PyObject * obj0 = 0 ;
8269 char * kwnames[] = {
8270 (char *) "pt", NULL
8271 };
8272
8273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8274 {
8275 arg1 = &temp1;
8276 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8277 }
8278 {
8279 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8283 return resultobj;
8284 fail:
8285 return NULL;
8286 }
8287
8288
8289 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8290 PyObject *resultobj = 0;
8291 wxPoint *arg1 = 0 ;
8292 wxPoint2D *result = 0 ;
8293 wxPoint temp1 ;
8294 PyObject * obj0 = 0 ;
8295 char * kwnames[] = {
8296 (char *) "pt", NULL
8297 };
8298
8299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8300 {
8301 arg1 = &temp1;
8302 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8303 }
8304 {
8305 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8316 PyObject *resultobj = 0;
8317 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 PyObject *swig_obj[1] ;
8321
8322 if (!args) SWIG_fail;
8323 swig_obj[0] = args;
8324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8327 }
8328 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8329 {
8330 delete arg1;
8331
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 resultobj = SWIG_Py_Void();
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342 PyObject *resultobj = 0;
8343 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8344 int *arg2 = (int *) 0 ;
8345 int *arg3 = (int *) 0 ;
8346 void *argp1 = 0 ;
8347 int res1 = 0 ;
8348 int temp2 ;
8349 int res2 = SWIG_TMPOBJ ;
8350 int temp3 ;
8351 int res3 = SWIG_TMPOBJ ;
8352 PyObject *swig_obj[1] ;
8353
8354 arg2 = &temp2;
8355 arg3 = &temp3;
8356 if (!args) SWIG_fail;
8357 swig_obj[0] = args;
8358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8361 }
8362 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8363 {
8364 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8365 if (PyErr_Occurred()) SWIG_fail;
8366 }
8367 resultobj = SWIG_Py_Void();
8368 if (SWIG_IsTmpObj(res2)) {
8369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8370 } else {
8371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8373 }
8374 if (SWIG_IsTmpObj(res3)) {
8375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8376 } else {
8377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8379 }
8380 return resultobj;
8381 fail:
8382 return NULL;
8383 }
8384
8385
8386 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387 PyObject *resultobj = 0;
8388 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8389 int *arg2 = (int *) 0 ;
8390 int *arg3 = (int *) 0 ;
8391 void *argp1 = 0 ;
8392 int res1 = 0 ;
8393 int temp2 ;
8394 int res2 = SWIG_TMPOBJ ;
8395 int temp3 ;
8396 int res3 = SWIG_TMPOBJ ;
8397 PyObject *swig_obj[1] ;
8398
8399 arg2 = &temp2;
8400 arg3 = &temp3;
8401 if (!args) SWIG_fail;
8402 swig_obj[0] = args;
8403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8404 if (!SWIG_IsOK(res1)) {
8405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8406 }
8407 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8408 {
8409 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_Py_Void();
8413 if (SWIG_IsTmpObj(res2)) {
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8415 } else {
8416 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8418 }
8419 if (SWIG_IsTmpObj(res3)) {
8420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8421 } else {
8422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8424 }
8425 return resultobj;
8426 fail:
8427 return NULL;
8428 }
8429
8430
8431 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8432 PyObject *resultobj = 0;
8433 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8434 double result;
8435 void *argp1 = 0 ;
8436 int res1 = 0 ;
8437 PyObject *swig_obj[1] ;
8438
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8444 }
8445 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8446 {
8447 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_From_double(static_cast< double >(result));
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 double result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 PyObject *swig_obj[1] ;
8464
8465 if (!args) SWIG_fail;
8466 swig_obj[0] = args;
8467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8468 if (!SWIG_IsOK(res1)) {
8469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8470 }
8471 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8472 {
8473 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8474 if (PyErr_Occurred()) SWIG_fail;
8475 }
8476 resultobj = SWIG_From_double(static_cast< double >(result));
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8484 PyObject *resultobj = 0;
8485 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8486 double arg2 ;
8487 void *argp1 = 0 ;
8488 int res1 = 0 ;
8489 double val2 ;
8490 int ecode2 = 0 ;
8491 PyObject * obj0 = 0 ;
8492 PyObject * obj1 = 0 ;
8493 char * kwnames[] = {
8494 (char *) "self",(char *) "length", NULL
8495 };
8496
8497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 ecode2 = SWIG_AsVal_double(obj1, &val2);
8504 if (!SWIG_IsOK(ecode2)) {
8505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8506 }
8507 arg2 = static_cast< double >(val2);
8508 {
8509 (arg1)->SetVectorLength(arg2);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_Py_Void();
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj = 0;
8521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8522 double arg2 ;
8523 void *argp1 = 0 ;
8524 int res1 = 0 ;
8525 double val2 ;
8526 int ecode2 = 0 ;
8527 PyObject * obj0 = 0 ;
8528 PyObject * obj1 = 0 ;
8529 char * kwnames[] = {
8530 (char *) "self",(char *) "degrees", NULL
8531 };
8532
8533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8535 if (!SWIG_IsOK(res1)) {
8536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8537 }
8538 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8539 ecode2 = SWIG_AsVal_double(obj1, &val2);
8540 if (!SWIG_IsOK(ecode2)) {
8541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8542 }
8543 arg2 = static_cast< double >(val2);
8544 {
8545 (arg1)->SetVectorAngle(arg2);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_Py_Void();
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 wxPoint2D *arg2 = 0 ;
8559 double result;
8560 void *argp1 = 0 ;
8561 int res1 = 0 ;
8562 wxPoint2D temp2 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "pt", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 {
8576 arg2 = &temp2;
8577 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8578 }
8579 {
8580 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_From_double(static_cast< double >(result));
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = 0;
8592 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8593 wxPoint2D *arg2 = 0 ;
8594 double result;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 wxPoint2D temp2 ;
8598 PyObject * obj0 = 0 ;
8599 PyObject * obj1 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "self",(char *) "pt", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8608 }
8609 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8610 {
8611 arg2 = &temp2;
8612 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8613 }
8614 {
8615 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 resultobj = SWIG_From_double(static_cast< double >(result));
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj = 0;
8627 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8628 wxPoint2D *arg2 = 0 ;
8629 double result;
8630 void *argp1 = 0 ;
8631 int res1 = 0 ;
8632 wxPoint2D temp2 ;
8633 PyObject * obj0 = 0 ;
8634 PyObject * obj1 = 0 ;
8635 char * kwnames[] = {
8636 (char *) "self",(char *) "vec", NULL
8637 };
8638
8639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8641 if (!SWIG_IsOK(res1)) {
8642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8643 }
8644 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8645 {
8646 arg2 = &temp2;
8647 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8648 }
8649 {
8650 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 resultobj = SWIG_From_double(static_cast< double >(result));
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 wxPoint2D *arg2 = 0 ;
8664 double result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 wxPoint2D temp2 ;
8668 PyObject * obj0 = 0 ;
8669 PyObject * obj1 = 0 ;
8670 char * kwnames[] = {
8671 (char *) "self",(char *) "vec", NULL
8672 };
8673
8674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8676 if (!SWIG_IsOK(res1)) {
8677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8678 }
8679 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8680 {
8681 arg2 = &temp2;
8682 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8683 }
8684 {
8685 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 resultobj = SWIG_From_double(static_cast< double >(result));
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696 PyObject *resultobj = 0;
8697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8698 wxPoint2D result;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 PyObject *swig_obj[1] ;
8702
8703 if (!args) SWIG_fail;
8704 swig_obj[0] = args;
8705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8706 if (!SWIG_IsOK(res1)) {
8707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8708 }
8709 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8710 {
8711 result = (arg1)->operator -();
8712 if (PyErr_Occurred()) SWIG_fail;
8713 }
8714 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8715 return resultobj;
8716 fail:
8717 return NULL;
8718 }
8719
8720
8721 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8722 PyObject *resultobj = 0;
8723 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8724 wxPoint2D *arg2 = 0 ;
8725 wxPoint2D *result = 0 ;
8726 void *argp1 = 0 ;
8727 int res1 = 0 ;
8728 wxPoint2D temp2 ;
8729 PyObject * obj0 = 0 ;
8730 PyObject * obj1 = 0 ;
8731 char * kwnames[] = {
8732 (char *) "self",(char *) "pt", NULL
8733 };
8734
8735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8737 if (!SWIG_IsOK(res1)) {
8738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8739 }
8740 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8741 {
8742 arg2 = &temp2;
8743 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8744 }
8745 {
8746 {
8747 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8748 result = (wxPoint2D *) &_result_ref;
8749 }
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8753 return resultobj;
8754 fail:
8755 return NULL;
8756 }
8757
8758
8759 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8760 PyObject *resultobj = 0;
8761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8762 wxPoint2D *arg2 = 0 ;
8763 wxPoint2D *result = 0 ;
8764 void *argp1 = 0 ;
8765 int res1 = 0 ;
8766 wxPoint2D temp2 ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "pt", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8777 }
8778 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8779 {
8780 arg2 = &temp2;
8781 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8782 }
8783 {
8784 {
8785 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8786 result = (wxPoint2D *) &_result_ref;
8787 }
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8800 wxPoint2D *arg2 = 0 ;
8801 wxPoint2D *result = 0 ;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 wxPoint2D temp2 ;
8805 PyObject * obj0 = 0 ;
8806 PyObject * obj1 = 0 ;
8807 char * kwnames[] = {
8808 (char *) "self",(char *) "pt", NULL
8809 };
8810
8811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8813 if (!SWIG_IsOK(res1)) {
8814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8815 }
8816 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8817 {
8818 arg2 = &temp2;
8819 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8820 }
8821 {
8822 {
8823 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8824 result = (wxPoint2D *) &_result_ref;
8825 }
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8838 wxPoint2D *arg2 = 0 ;
8839 wxPoint2D *result = 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 wxPoint2D temp2 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "pt", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 {
8856 arg2 = &temp2;
8857 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8858 }
8859 {
8860 {
8861 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8862 result = (wxPoint2D *) &_result_ref;
8863 }
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8867 return resultobj;
8868 fail:
8869 return NULL;
8870 }
8871
8872
8873 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8874 PyObject *resultobj = 0;
8875 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8876 PyObject *arg2 = (PyObject *) 0 ;
8877 bool result;
8878 void *argp1 = 0 ;
8879 int res1 = 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char * kwnames[] = {
8883 (char *) "self",(char *) "other", NULL
8884 };
8885
8886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8890 }
8891 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8892 arg2 = obj1;
8893 {
8894 result = (bool)wxPoint2D___eq__(arg1,arg2);
8895 if (PyErr_Occurred()) SWIG_fail;
8896 }
8897 {
8898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8899 }
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 PyObject *arg2 = (PyObject *) 0 ;
8910 bool result;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 char * kwnames[] = {
8916 (char *) "self",(char *) "other", NULL
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8923 }
8924 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8925 arg2 = obj1;
8926 {
8927 result = (bool)wxPoint2D___ne__(arg1,arg2);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 {
8931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8932 }
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8940 PyObject *resultobj = 0;
8941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8942 double arg2 ;
8943 void *argp1 = 0 ;
8944 int res1 = 0 ;
8945 double val2 ;
8946 int ecode2 = 0 ;
8947 PyObject *swig_obj[2] ;
8948
8949 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8955 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8956 if (!SWIG_IsOK(ecode2)) {
8957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8958 }
8959 arg2 = static_cast< double >(val2);
8960 if (arg1) (arg1)->m_x = arg2;
8961
8962 resultobj = SWIG_Py_Void();
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *resultobj = 0;
8971 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8972 double result;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject *swig_obj[1] ;
8976
8977 if (!args) SWIG_fail;
8978 swig_obj[0] = args;
8979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8980 if (!SWIG_IsOK(res1)) {
8981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8982 }
8983 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8984 result = (double) ((arg1)->m_x);
8985 resultobj = SWIG_From_double(static_cast< double >(result));
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 PyObject *resultobj = 0;
8994 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8995 double arg2 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 double val2 ;
8999 int ecode2 = 0 ;
9000 PyObject *swig_obj[2] ;
9001
9002 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9006 }
9007 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9008 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9009 if (!SWIG_IsOK(ecode2)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9011 }
9012 arg2 = static_cast< double >(val2);
9013 if (arg1) (arg1)->m_y = arg2;
9014
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *resultobj = 0;
9024 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9025 double result;
9026 void *argp1 = 0 ;
9027 int res1 = 0 ;
9028 PyObject *swig_obj[1] ;
9029
9030 if (!args) SWIG_fail;
9031 swig_obj[0] = args;
9032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9033 if (!SWIG_IsOK(res1)) {
9034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9035 }
9036 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9037 result = (double) ((arg1)->m_y);
9038 resultobj = SWIG_From_double(static_cast< double >(result));
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9048 double arg2 = (double) 0 ;
9049 double arg3 = (double) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 double val2 ;
9053 int ecode2 = 0 ;
9054 double val3 ;
9055 int ecode3 = 0 ;
9056 PyObject * obj0 = 0 ;
9057 PyObject * obj1 = 0 ;
9058 PyObject * obj2 = 0 ;
9059 char * kwnames[] = {
9060 (char *) "self",(char *) "x",(char *) "y", NULL
9061 };
9062
9063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9065 if (!SWIG_IsOK(res1)) {
9066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9067 }
9068 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9069 if (obj1) {
9070 ecode2 = SWIG_AsVal_double(obj1, &val2);
9071 if (!SWIG_IsOK(ecode2)) {
9072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9073 }
9074 arg2 = static_cast< double >(val2);
9075 }
9076 if (obj2) {
9077 ecode3 = SWIG_AsVal_double(obj2, &val3);
9078 if (!SWIG_IsOK(ecode3)) {
9079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9080 }
9081 arg3 = static_cast< double >(val3);
9082 }
9083 {
9084 wxPoint2D_Set(arg1,arg2,arg3);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *resultobj = 0;
9096 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9097 PyObject *result = 0 ;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 PyObject *swig_obj[1] ;
9101
9102 if (!args) SWIG_fail;
9103 swig_obj[0] = args;
9104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9105 if (!SWIG_IsOK(res1)) {
9106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9107 }
9108 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9109 {
9110 result = (PyObject *)wxPoint2D_Get(arg1);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 resultobj = result;
9114 return resultobj;
9115 fail:
9116 return NULL;
9117 }
9118
9119
9120 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9121 PyObject *obj;
9122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9123 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9124 return SWIG_Py_Void();
9125 }
9126
9127 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9128 return SWIG_Python_InitShadowInstance(args);
9129 }
9130
9131 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj = 0;
9133 wxDouble arg1 = (wxDouble) 0.0 ;
9134 wxDouble arg2 = (wxDouble) 0.0 ;
9135 wxDouble arg3 = (wxDouble) 0.0 ;
9136 wxDouble arg4 = (wxDouble) 0.0 ;
9137 wxRect2D *result = 0 ;
9138 void *argp1 ;
9139 int res1 = 0 ;
9140 void *argp2 ;
9141 int res2 = 0 ;
9142 void *argp3 ;
9143 int res3 = 0 ;
9144 void *argp4 ;
9145 int res4 = 0 ;
9146 PyObject * obj0 = 0 ;
9147 PyObject * obj1 = 0 ;
9148 PyObject * obj2 = 0 ;
9149 PyObject * obj3 = 0 ;
9150 char * kwnames[] = {
9151 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9152 };
9153
9154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9155 if (obj0) {
9156 {
9157 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9158 if (!SWIG_IsOK(res1)) {
9159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9160 }
9161 if (!argp1) {
9162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9163 } else {
9164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9165 arg1 = *temp;
9166 if (SWIG_IsNewObj(res1)) delete temp;
9167 }
9168 }
9169 }
9170 if (obj1) {
9171 {
9172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9173 if (!SWIG_IsOK(res2)) {
9174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9175 }
9176 if (!argp2) {
9177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9178 } else {
9179 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9180 arg2 = *temp;
9181 if (SWIG_IsNewObj(res2)) delete temp;
9182 }
9183 }
9184 }
9185 if (obj2) {
9186 {
9187 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9188 if (!SWIG_IsOK(res3)) {
9189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9190 }
9191 if (!argp3) {
9192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9193 } else {
9194 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9195 arg3 = *temp;
9196 if (SWIG_IsNewObj(res3)) delete temp;
9197 }
9198 }
9199 }
9200 if (obj3) {
9201 {
9202 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9203 if (!SWIG_IsOK(res4)) {
9204 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9205 }
9206 if (!argp4) {
9207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9208 } else {
9209 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9210 arg4 = *temp;
9211 if (SWIG_IsNewObj(res4)) delete temp;
9212 }
9213 }
9214 }
9215 {
9216 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxRect2D *arg1 = (wxRect2D *) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9238 }
9239 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9240 {
9241 delete arg1;
9242
9243 if (PyErr_Occurred()) SWIG_fail;
9244 }
9245 resultobj = SWIG_Py_Void();
9246 return resultobj;
9247 fail:
9248 return NULL;
9249 }
9250
9251
9252 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9253 PyObject *resultobj = 0;
9254 wxRect2D *arg1 = (wxRect2D *) 0 ;
9255 wxPoint2D result;
9256 void *argp1 = 0 ;
9257 int res1 = 0 ;
9258 PyObject *swig_obj[1] ;
9259
9260 if (!args) SWIG_fail;
9261 swig_obj[0] = args;
9262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9263 if (!SWIG_IsOK(res1)) {
9264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9265 }
9266 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9267 {
9268 result = (arg1)->GetPosition();
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxRect2D *arg1 = (wxRect2D *) 0 ;
9281 wxSize result;
9282 void *argp1 = 0 ;
9283 int res1 = 0 ;
9284 PyObject *swig_obj[1] ;
9285
9286 if (!args) SWIG_fail;
9287 swig_obj[0] = args;
9288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9291 }
9292 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9293 {
9294 result = (arg1)->GetSize();
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9305 PyObject *resultobj = 0;
9306 wxRect2D *arg1 = (wxRect2D *) 0 ;
9307 wxDouble result;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 PyObject *swig_obj[1] ;
9311
9312 if (!args) SWIG_fail;
9313 swig_obj[0] = args;
9314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9315 if (!SWIG_IsOK(res1)) {
9316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9317 }
9318 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9319 {
9320 result = ((wxRect2D const *)arg1)->GetLeft();
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj = 0;
9332 wxRect2D *arg1 = (wxRect2D *) 0 ;
9333 wxDouble arg2 ;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 void *argp2 ;
9337 int res2 = 0 ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 char * kwnames[] = {
9341 (char *) "self",(char *) "n", NULL
9342 };
9343
9344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9348 }
9349 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9350 {
9351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9352 if (!SWIG_IsOK(res2)) {
9353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9354 }
9355 if (!argp2) {
9356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9357 } else {
9358 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9359 arg2 = *temp;
9360 if (SWIG_IsNewObj(res2)) delete temp;
9361 }
9362 }
9363 {
9364 (arg1)->SetLeft(arg2);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 resultobj = SWIG_Py_Void();
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9375 PyObject *resultobj = 0;
9376 wxRect2D *arg1 = (wxRect2D *) 0 ;
9377 wxDouble arg2 ;
9378 void *argp1 = 0 ;
9379 int res1 = 0 ;
9380 void *argp2 ;
9381 int res2 = 0 ;
9382 PyObject * obj0 = 0 ;
9383 PyObject * obj1 = 0 ;
9384 char * kwnames[] = {
9385 (char *) "self",(char *) "n", NULL
9386 };
9387
9388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9390 if (!SWIG_IsOK(res1)) {
9391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9392 }
9393 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9394 {
9395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9396 if (!SWIG_IsOK(res2)) {
9397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9398 }
9399 if (!argp2) {
9400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9401 } else {
9402 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9403 arg2 = *temp;
9404 if (SWIG_IsNewObj(res2)) delete temp;
9405 }
9406 }
9407 {
9408 (arg1)->MoveLeftTo(arg2);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 resultobj = SWIG_Py_Void();
9412 return resultobj;
9413 fail:
9414 return NULL;
9415 }
9416
9417
9418 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9419 PyObject *resultobj = 0;
9420 wxRect2D *arg1 = (wxRect2D *) 0 ;
9421 wxDouble result;
9422 void *argp1 = 0 ;
9423 int res1 = 0 ;
9424 PyObject *swig_obj[1] ;
9425
9426 if (!args) SWIG_fail;
9427 swig_obj[0] = args;
9428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9431 }
9432 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9433 {
9434 result = ((wxRect2D const *)arg1)->GetTop();
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj = 0;
9446 wxRect2D *arg1 = (wxRect2D *) 0 ;
9447 wxDouble arg2 ;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 void *argp2 ;
9451 int res2 = 0 ;
9452 PyObject * obj0 = 0 ;
9453 PyObject * obj1 = 0 ;
9454 char * kwnames[] = {
9455 (char *) "self",(char *) "n", NULL
9456 };
9457
9458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9460 if (!SWIG_IsOK(res1)) {
9461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9462 }
9463 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9464 {
9465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9466 if (!SWIG_IsOK(res2)) {
9467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9468 }
9469 if (!argp2) {
9470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9471 } else {
9472 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9473 arg2 = *temp;
9474 if (SWIG_IsNewObj(res2)) delete temp;
9475 }
9476 }
9477 {
9478 (arg1)->SetTop(arg2);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_Py_Void();
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxRect2D *arg1 = (wxRect2D *) 0 ;
9491 wxDouble arg2 ;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 void *argp2 ;
9495 int res2 = 0 ;
9496 PyObject * obj0 = 0 ;
9497 PyObject * obj1 = 0 ;
9498 char * kwnames[] = {
9499 (char *) "self",(char *) "n", NULL
9500 };
9501
9502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9504 if (!SWIG_IsOK(res1)) {
9505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9506 }
9507 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9508 {
9509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9510 if (!SWIG_IsOK(res2)) {
9511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9512 }
9513 if (!argp2) {
9514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9515 } else {
9516 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9517 arg2 = *temp;
9518 if (SWIG_IsNewObj(res2)) delete temp;
9519 }
9520 }
9521 {
9522 (arg1)->MoveTopTo(arg2);
9523 if (PyErr_Occurred()) SWIG_fail;
9524 }
9525 resultobj = SWIG_Py_Void();
9526 return resultobj;
9527 fail:
9528 return NULL;
9529 }
9530
9531
9532 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9533 PyObject *resultobj = 0;
9534 wxRect2D *arg1 = (wxRect2D *) 0 ;
9535 wxDouble result;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 PyObject *swig_obj[1] ;
9539
9540 if (!args) SWIG_fail;
9541 swig_obj[0] = args;
9542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9543 if (!SWIG_IsOK(res1)) {
9544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9545 }
9546 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9547 {
9548 result = ((wxRect2D const *)arg1)->GetBottom();
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9552 return resultobj;
9553 fail:
9554 return NULL;
9555 }
9556
9557
9558 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj = 0;
9560 wxRect2D *arg1 = (wxRect2D *) 0 ;
9561 wxDouble arg2 ;
9562 void *argp1 = 0 ;
9563 int res1 = 0 ;
9564 void *argp2 ;
9565 int res2 = 0 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "n", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9576 }
9577 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9578 {
9579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9580 if (!SWIG_IsOK(res2)) {
9581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9582 }
9583 if (!argp2) {
9584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9585 } else {
9586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9587 arg2 = *temp;
9588 if (SWIG_IsNewObj(res2)) delete temp;
9589 }
9590 }
9591 {
9592 (arg1)->SetBottom(arg2);
9593 if (PyErr_Occurred()) SWIG_fail;
9594 }
9595 resultobj = SWIG_Py_Void();
9596 return resultobj;
9597 fail:
9598 return NULL;
9599 }
9600
9601
9602 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9603 PyObject *resultobj = 0;
9604 wxRect2D *arg1 = (wxRect2D *) 0 ;
9605 wxDouble arg2 ;
9606 void *argp1 = 0 ;
9607 int res1 = 0 ;
9608 void *argp2 ;
9609 int res2 = 0 ;
9610 PyObject * obj0 = 0 ;
9611 PyObject * obj1 = 0 ;
9612 char * kwnames[] = {
9613 (char *) "self",(char *) "n", NULL
9614 };
9615
9616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9620 }
9621 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9622 {
9623 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9624 if (!SWIG_IsOK(res2)) {
9625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9626 }
9627 if (!argp2) {
9628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9629 } else {
9630 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9631 arg2 = *temp;
9632 if (SWIG_IsNewObj(res2)) delete temp;
9633 }
9634 }
9635 {
9636 (arg1)->MoveBottomTo(arg2);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_Py_Void();
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9647 PyObject *resultobj = 0;
9648 wxRect2D *arg1 = (wxRect2D *) 0 ;
9649 wxDouble result;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 PyObject *swig_obj[1] ;
9653
9654 if (!args) SWIG_fail;
9655 swig_obj[0] = args;
9656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9659 }
9660 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9661 {
9662 result = ((wxRect2D const *)arg1)->GetRight();
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9666 return resultobj;
9667 fail:
9668 return NULL;
9669 }
9670
9671
9672 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9673 PyObject *resultobj = 0;
9674 wxRect2D *arg1 = (wxRect2D *) 0 ;
9675 wxDouble arg2 ;
9676 void *argp1 = 0 ;
9677 int res1 = 0 ;
9678 void *argp2 ;
9679 int res2 = 0 ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 char * kwnames[] = {
9683 (char *) "self",(char *) "n", NULL
9684 };
9685
9686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9688 if (!SWIG_IsOK(res1)) {
9689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9690 }
9691 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9692 {
9693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9694 if (!SWIG_IsOK(res2)) {
9695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9696 }
9697 if (!argp2) {
9698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9699 } else {
9700 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9701 arg2 = *temp;
9702 if (SWIG_IsNewObj(res2)) delete temp;
9703 }
9704 }
9705 {
9706 (arg1)->SetRight(arg2);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9717 PyObject *resultobj = 0;
9718 wxRect2D *arg1 = (wxRect2D *) 0 ;
9719 wxDouble arg2 ;
9720 void *argp1 = 0 ;
9721 int res1 = 0 ;
9722 void *argp2 ;
9723 int res2 = 0 ;
9724 PyObject * obj0 = 0 ;
9725 PyObject * obj1 = 0 ;
9726 char * kwnames[] = {
9727 (char *) "self",(char *) "n", NULL
9728 };
9729
9730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9732 if (!SWIG_IsOK(res1)) {
9733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9734 }
9735 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9736 {
9737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9738 if (!SWIG_IsOK(res2)) {
9739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9740 }
9741 if (!argp2) {
9742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9743 } else {
9744 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9745 arg2 = *temp;
9746 if (SWIG_IsNewObj(res2)) delete temp;
9747 }
9748 }
9749 {
9750 (arg1)->MoveRightTo(arg2);
9751 if (PyErr_Occurred()) SWIG_fail;
9752 }
9753 resultobj = SWIG_Py_Void();
9754 return resultobj;
9755 fail:
9756 return NULL;
9757 }
9758
9759
9760 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9761 PyObject *resultobj = 0;
9762 wxRect2D *arg1 = (wxRect2D *) 0 ;
9763 wxPoint2D result;
9764 void *argp1 = 0 ;
9765 int res1 = 0 ;
9766 PyObject *swig_obj[1] ;
9767
9768 if (!args) SWIG_fail;
9769 swig_obj[0] = args;
9770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9771 if (!SWIG_IsOK(res1)) {
9772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9773 }
9774 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9775 {
9776 result = ((wxRect2D const *)arg1)->GetLeftTop();
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj = 0;
9788 wxRect2D *arg1 = (wxRect2D *) 0 ;
9789 wxPoint2D *arg2 = 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 wxPoint2D temp2 ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 char * kwnames[] = {
9796 (char *) "self",(char *) "pt", NULL
9797 };
9798
9799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9801 if (!SWIG_IsOK(res1)) {
9802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9803 }
9804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9805 {
9806 arg2 = &temp2;
9807 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9808 }
9809 {
9810 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_Py_Void();
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9821 PyObject *resultobj = 0;
9822 wxRect2D *arg1 = (wxRect2D *) 0 ;
9823 wxPoint2D *arg2 = 0 ;
9824 void *argp1 = 0 ;
9825 int res1 = 0 ;
9826 wxPoint2D temp2 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char * kwnames[] = {
9830 (char *) "self",(char *) "pt", NULL
9831 };
9832
9833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9837 }
9838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9839 {
9840 arg2 = &temp2;
9841 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9842 }
9843 {
9844 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 resultobj = SWIG_Py_Void();
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *resultobj = 0;
9856 wxRect2D *arg1 = (wxRect2D *) 0 ;
9857 wxPoint2D result;
9858 void *argp1 = 0 ;
9859 int res1 = 0 ;
9860 PyObject *swig_obj[1] ;
9861
9862 if (!args) SWIG_fail;
9863 swig_obj[0] = args;
9864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9867 }
9868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9869 {
9870 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = 0;
9882 wxRect2D *arg1 = (wxRect2D *) 0 ;
9883 wxPoint2D *arg2 = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 wxPoint2D temp2 ;
9887 PyObject * obj0 = 0 ;
9888 PyObject * obj1 = 0 ;
9889 char * kwnames[] = {
9890 (char *) "self",(char *) "pt", NULL
9891 };
9892
9893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9895 if (!SWIG_IsOK(res1)) {
9896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9897 }
9898 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9899 {
9900 arg2 = &temp2;
9901 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9902 }
9903 {
9904 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 resultobj = SWIG_Py_Void();
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj = 0;
9916 wxRect2D *arg1 = (wxRect2D *) 0 ;
9917 wxPoint2D *arg2 = 0 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 wxPoint2D temp2 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char * kwnames[] = {
9924 (char *) "self",(char *) "pt", NULL
9925 };
9926
9927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9931 }
9932 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9933 {
9934 arg2 = &temp2;
9935 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9936 }
9937 {
9938 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 resultobj = SWIG_Py_Void();
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9949 PyObject *resultobj = 0;
9950 wxRect2D *arg1 = (wxRect2D *) 0 ;
9951 wxPoint2D result;
9952 void *argp1 = 0 ;
9953 int res1 = 0 ;
9954 PyObject *swig_obj[1] ;
9955
9956 if (!args) SWIG_fail;
9957 swig_obj[0] = args;
9958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9961 }
9962 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9963 {
9964 result = ((wxRect2D const *)arg1)->GetRightTop();
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9968 return resultobj;
9969 fail:
9970 return NULL;
9971 }
9972
9973
9974 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj = 0;
9976 wxRect2D *arg1 = (wxRect2D *) 0 ;
9977 wxPoint2D *arg2 = 0 ;
9978 void *argp1 = 0 ;
9979 int res1 = 0 ;
9980 wxPoint2D temp2 ;
9981 PyObject * obj0 = 0 ;
9982 PyObject * obj1 = 0 ;
9983 char * kwnames[] = {
9984 (char *) "self",(char *) "pt", NULL
9985 };
9986
9987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9991 }
9992 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9993 {
9994 arg2 = &temp2;
9995 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9996 }
9997 {
9998 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_Py_Void();
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxRect2D *arg1 = (wxRect2D *) 0 ;
10011 wxPoint2D *arg2 = 0 ;
10012 void *argp1 = 0 ;
10013 int res1 = 0 ;
10014 wxPoint2D temp2 ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 char * kwnames[] = {
10018 (char *) "self",(char *) "pt", NULL
10019 };
10020
10021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10025 }
10026 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10027 {
10028 arg2 = &temp2;
10029 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10030 }
10031 {
10032 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037 fail:
10038 return NULL;
10039 }
10040
10041
10042 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxRect2D *arg1 = (wxRect2D *) 0 ;
10045 wxPoint2D result;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 PyObject *swig_obj[1] ;
10049
10050 if (!args) SWIG_fail;
10051 swig_obj[0] = args;
10052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10055 }
10056 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10057 {
10058 result = ((wxRect2D const *)arg1)->GetRightBottom();
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxRect2D *arg1 = (wxRect2D *) 0 ;
10071 wxPoint2D *arg2 = 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 wxPoint2D temp2 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "pt", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10085 }
10086 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10087 {
10088 arg2 = &temp2;
10089 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10090 }
10091 {
10092 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxRect2D *arg1 = (wxRect2D *) 0 ;
10105 wxPoint2D *arg2 = 0 ;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 wxPoint2D temp2 ;
10109 PyObject * obj0 = 0 ;
10110 PyObject * obj1 = 0 ;
10111 char * kwnames[] = {
10112 (char *) "self",(char *) "pt", NULL
10113 };
10114
10115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10119 }
10120 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10121 {
10122 arg2 = &temp2;
10123 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10124 }
10125 {
10126 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 resultobj = SWIG_Py_Void();
10130 return resultobj;
10131 fail:
10132 return NULL;
10133 }
10134
10135
10136 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10137 PyObject *resultobj = 0;
10138 wxRect2D *arg1 = (wxRect2D *) 0 ;
10139 wxPoint2D result;
10140 void *argp1 = 0 ;
10141 int res1 = 0 ;
10142 PyObject *swig_obj[1] ;
10143
10144 if (!args) SWIG_fail;
10145 swig_obj[0] = args;
10146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10149 }
10150 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10151 {
10152 result = ((wxRect2D const *)arg1)->GetCentre();
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxRect2D *arg1 = (wxRect2D *) 0 ;
10165 wxPoint2D *arg2 = 0 ;
10166 void *argp1 = 0 ;
10167 int res1 = 0 ;
10168 wxPoint2D temp2 ;
10169 PyObject * obj0 = 0 ;
10170 PyObject * obj1 = 0 ;
10171 char * kwnames[] = {
10172 (char *) "self",(char *) "pt", NULL
10173 };
10174
10175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10179 }
10180 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10181 {
10182 arg2 = &temp2;
10183 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10184 }
10185 {
10186 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 resultobj = SWIG_Py_Void();
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = 0;
10198 wxRect2D *arg1 = (wxRect2D *) 0 ;
10199 wxPoint2D *arg2 = 0 ;
10200 void *argp1 = 0 ;
10201 int res1 = 0 ;
10202 wxPoint2D temp2 ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char * kwnames[] = {
10206 (char *) "self",(char *) "pt", NULL
10207 };
10208
10209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10211 if (!SWIG_IsOK(res1)) {
10212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10213 }
10214 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10215 {
10216 arg2 = &temp2;
10217 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10218 }
10219 {
10220 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 resultobj = SWIG_Py_Void();
10224 return resultobj;
10225 fail:
10226 return NULL;
10227 }
10228
10229
10230 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj = 0;
10232 wxRect2D *arg1 = (wxRect2D *) 0 ;
10233 wxPoint2D *arg2 = 0 ;
10234 wxOutCode result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 wxPoint2D temp2 ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240 char * kwnames[] = {
10241 (char *) "self",(char *) "pt", NULL
10242 };
10243
10244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10246 if (!SWIG_IsOK(res1)) {
10247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10248 }
10249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10250 {
10251 arg2 = &temp2;
10252 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10253 }
10254 {
10255 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 resultobj = SWIG_From_int(static_cast< int >(result));
10259 return resultobj;
10260 fail:
10261 return NULL;
10262 }
10263
10264
10265 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10266 PyObject *resultobj = 0;
10267 wxRect2D *arg1 = (wxRect2D *) 0 ;
10268 wxPoint2D *arg2 = 0 ;
10269 bool result;
10270 void *argp1 = 0 ;
10271 int res1 = 0 ;
10272 wxPoint2D temp2 ;
10273 PyObject * obj0 = 0 ;
10274 PyObject * obj1 = 0 ;
10275 char * kwnames[] = {
10276 (char *) "self",(char *) "pt", NULL
10277 };
10278
10279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10283 }
10284 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10285 {
10286 arg2 = &temp2;
10287 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10288 }
10289 {
10290 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10291 if (PyErr_Occurred()) SWIG_fail;
10292 }
10293 {
10294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10295 }
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxRect2D *arg1 = (wxRect2D *) 0 ;
10305 wxRect2D *arg2 = 0 ;
10306 bool result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 wxRect2D temp2 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "rect", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10320 }
10321 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10322 {
10323 arg2 = &temp2;
10324 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10325 }
10326 {
10327 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10328 if (PyErr_Occurred()) SWIG_fail;
10329 }
10330 {
10331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10332 }
10333 return resultobj;
10334 fail:
10335 return NULL;
10336 }
10337
10338
10339 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10340 PyObject *resultobj = 0;
10341 wxRect2D *arg1 = (wxRect2D *) 0 ;
10342 bool result;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 PyObject *swig_obj[1] ;
10346
10347 if (!args) SWIG_fail;
10348 swig_obj[0] = args;
10349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10352 }
10353 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10354 {
10355 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 {
10359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10360 }
10361 return resultobj;
10362 fail:
10363 return NULL;
10364 }
10365
10366
10367 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj = 0;
10369 wxRect2D *arg1 = (wxRect2D *) 0 ;
10370 wxRect2D *arg2 = 0 ;
10371 bool result;
10372 void *argp1 = 0 ;
10373 int res1 = 0 ;
10374 wxRect2D temp2 ;
10375 PyObject * obj0 = 0 ;
10376 PyObject * obj1 = 0 ;
10377 char * kwnames[] = {
10378 (char *) "self",(char *) "rect", NULL
10379 };
10380
10381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10383 if (!SWIG_IsOK(res1)) {
10384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10385 }
10386 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10387 {
10388 arg2 = &temp2;
10389 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10390 }
10391 {
10392 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 {
10396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10397 }
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10405 PyObject *resultobj = 0;
10406 wxRect2D *arg1 = (wxRect2D *) 0 ;
10407 wxDouble arg2 ;
10408 wxDouble arg3 ;
10409 void *argp1 = 0 ;
10410 int res1 = 0 ;
10411 void *argp2 ;
10412 int res2 = 0 ;
10413 void *argp3 ;
10414 int res3 = 0 ;
10415
10416 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10420 }
10421 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10422 {
10423 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10424 if (!SWIG_IsOK(res2)) {
10425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10426 }
10427 if (!argp2) {
10428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10429 } else {
10430 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10431 arg2 = *temp;
10432 if (SWIG_IsNewObj(res2)) delete temp;
10433 }
10434 }
10435 {
10436 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10437 if (!SWIG_IsOK(res3)) {
10438 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10439 }
10440 if (!argp3) {
10441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10442 } else {
10443 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10444 arg3 = *temp;
10445 if (SWIG_IsNewObj(res3)) delete temp;
10446 }
10447 }
10448 {
10449 (arg1)->Inset(arg2,arg3);
10450 if (PyErr_Occurred()) SWIG_fail;
10451 }
10452 resultobj = SWIG_Py_Void();
10453 return resultobj;
10454 fail:
10455 return NULL;
10456 }
10457
10458
10459 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10460 PyObject *resultobj = 0;
10461 wxRect2D *arg1 = (wxRect2D *) 0 ;
10462 wxDouble arg2 ;
10463 wxDouble arg3 ;
10464 wxDouble arg4 ;
10465 wxDouble arg5 ;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 void *argp2 ;
10469 int res2 = 0 ;
10470 void *argp3 ;
10471 int res3 = 0 ;
10472 void *argp4 ;
10473 int res4 = 0 ;
10474 void *argp5 ;
10475 int res5 = 0 ;
10476
10477 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10481 }
10482 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10483 {
10484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10485 if (!SWIG_IsOK(res2)) {
10486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10487 }
10488 if (!argp2) {
10489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10490 } else {
10491 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10492 arg2 = *temp;
10493 if (SWIG_IsNewObj(res2)) delete temp;
10494 }
10495 }
10496 {
10497 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10498 if (!SWIG_IsOK(res3)) {
10499 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10500 }
10501 if (!argp3) {
10502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10503 } else {
10504 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10505 arg3 = *temp;
10506 if (SWIG_IsNewObj(res3)) delete temp;
10507 }
10508 }
10509 {
10510 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10511 if (!SWIG_IsOK(res4)) {
10512 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10513 }
10514 if (!argp4) {
10515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10516 } else {
10517 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10518 arg4 = *temp;
10519 if (SWIG_IsNewObj(res4)) delete temp;
10520 }
10521 }
10522 {
10523 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10524 if (!SWIG_IsOK(res5)) {
10525 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10526 }
10527 if (!argp5) {
10528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10529 } else {
10530 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10531 arg5 = *temp;
10532 if (SWIG_IsNewObj(res5)) delete temp;
10533 }
10534 }
10535 {
10536 (arg1)->Inset(arg2,arg3,arg4,arg5);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 resultobj = SWIG_Py_Void();
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10547 int argc;
10548 PyObject *argv[6];
10549
10550 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10551 --argc;
10552 if (argc == 3) {
10553 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10554 }
10555 if (argc == 5) {
10556 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10557 }
10558
10559 fail:
10560 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10561 return NULL;
10562 }
10563
10564
10565 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10566 PyObject *resultobj = 0;
10567 wxRect2D *arg1 = (wxRect2D *) 0 ;
10568 wxPoint2D *arg2 = 0 ;
10569 void *argp1 = 0 ;
10570 int res1 = 0 ;
10571 wxPoint2D temp2 ;
10572 PyObject * obj0 = 0 ;
10573 PyObject * obj1 = 0 ;
10574 char * kwnames[] = {
10575 (char *) "self",(char *) "pt", NULL
10576 };
10577
10578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10582 }
10583 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10584 {
10585 arg2 = &temp2;
10586 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10587 }
10588 {
10589 (arg1)->Offset((wxPoint2D const &)*arg2);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 resultobj = SWIG_Py_Void();
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj = 0;
10601 wxRect2D *arg1 = (wxRect2D *) 0 ;
10602 wxRect2D *arg2 = 0 ;
10603 void *argp1 = 0 ;
10604 int res1 = 0 ;
10605 wxRect2D temp2 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 char * kwnames[] = {
10609 (char *) "self",(char *) "rect", NULL
10610 };
10611
10612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10614 if (!SWIG_IsOK(res1)) {
10615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10616 }
10617 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10618 {
10619 arg2 = &temp2;
10620 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10621 }
10622 {
10623 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 resultobj = SWIG_Py_Void();
10627 return resultobj;
10628 fail:
10629 return NULL;
10630 }
10631
10632
10633 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10634 PyObject *resultobj = 0;
10635 wxRect2D *arg1 = (wxRect2D *) 0 ;
10636 int arg2 ;
10637 int arg3 ;
10638 wxPoint2D result;
10639 void *argp1 = 0 ;
10640 int res1 = 0 ;
10641 int val2 ;
10642 int ecode2 = 0 ;
10643 int val3 ;
10644 int ecode3 = 0 ;
10645 PyObject * obj0 = 0 ;
10646 PyObject * obj1 = 0 ;
10647 PyObject * obj2 = 0 ;
10648 char * kwnames[] = {
10649 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10650 };
10651
10652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10656 }
10657 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10658 ecode2 = SWIG_AsVal_int(obj1, &val2);
10659 if (!SWIG_IsOK(ecode2)) {
10660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10661 }
10662 arg2 = static_cast< int >(val2);
10663 ecode3 = SWIG_AsVal_int(obj2, &val3);
10664 if (!SWIG_IsOK(ecode3)) {
10665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10666 }
10667 arg3 = static_cast< int >(val3);
10668 {
10669 result = (arg1)->Interpolate(arg2,arg3);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj = 0;
10681 wxRect2D *arg1 = (wxRect2D *) 0 ;
10682 wxRect2D *arg2 = 0 ;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 wxRect2D temp2 ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char * kwnames[] = {
10689 (char *) "self",(char *) "otherRect", NULL
10690 };
10691
10692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10696 }
10697 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10698 {
10699 arg2 = &temp2;
10700 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10701 }
10702 {
10703 (arg1)->Intersect((wxRect2D const &)*arg2);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 resultobj = SWIG_Py_Void();
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj = 0;
10715 wxRect2D *arg1 = (wxRect2D *) 0 ;
10716 wxRect2D *arg2 = 0 ;
10717 wxRect2D result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 wxRect2D temp2 ;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 char * kwnames[] = {
10724 (char *) "self",(char *) "otherRect", NULL
10725 };
10726
10727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10731 }
10732 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10733 {
10734 arg2 = &temp2;
10735 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10736 }
10737 {
10738 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10739 if (PyErr_Occurred()) SWIG_fail;
10740 }
10741 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj = 0;
10750 wxRect2D *arg1 = (wxRect2D *) 0 ;
10751 wxRect2D *arg2 = 0 ;
10752 bool result;
10753 void *argp1 = 0 ;
10754 int res1 = 0 ;
10755 wxRect2D temp2 ;
10756 PyObject * obj0 = 0 ;
10757 PyObject * obj1 = 0 ;
10758 char * kwnames[] = {
10759 (char *) "self",(char *) "rect", NULL
10760 };
10761
10762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10764 if (!SWIG_IsOK(res1)) {
10765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10766 }
10767 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10768 {
10769 arg2 = &temp2;
10770 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10771 }
10772 {
10773 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 {
10777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10778 }
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj = 0;
10787 wxRect2D *arg1 = (wxRect2D *) 0 ;
10788 wxRect2D *arg2 = 0 ;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 wxRect2D temp2 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "otherRect", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10802 }
10803 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10804 {
10805 arg2 = &temp2;
10806 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10807 }
10808 {
10809 (arg1)->Union((wxRect2D const &)*arg2);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_Py_Void();
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxRect2D *arg1 = (wxRect2D *) 0 ;
10822 wxRect2D *arg2 = 0 ;
10823 wxRect2D result;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 wxRect2D temp2 ;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "otherRect", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10837 }
10838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10839 {
10840 arg2 = &temp2;
10841 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10842 }
10843 {
10844 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10848 return resultobj;
10849 fail:
10850 return NULL;
10851 }
10852
10853
10854 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10855 PyObject *resultobj = 0;
10856 wxRect2D *arg1 = (wxRect2D *) 0 ;
10857 wxDouble arg2 ;
10858 void *argp1 = 0 ;
10859 int res1 = 0 ;
10860 void *argp2 ;
10861 int res2 = 0 ;
10862
10863 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10865 if (!SWIG_IsOK(res1)) {
10866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10867 }
10868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10869 {
10870 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10871 if (!SWIG_IsOK(res2)) {
10872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10873 }
10874 if (!argp2) {
10875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10876 } else {
10877 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10878 arg2 = *temp;
10879 if (SWIG_IsNewObj(res2)) delete temp;
10880 }
10881 }
10882 {
10883 (arg1)->Scale(arg2);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 resultobj = SWIG_Py_Void();
10887 return resultobj;
10888 fail:
10889 return NULL;
10890 }
10891
10892
10893 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10894 PyObject *resultobj = 0;
10895 wxRect2D *arg1 = (wxRect2D *) 0 ;
10896 int arg2 ;
10897 int arg3 ;
10898 void *argp1 = 0 ;
10899 int res1 = 0 ;
10900 int val2 ;
10901 int ecode2 = 0 ;
10902 int val3 ;
10903 int ecode3 = 0 ;
10904
10905 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10909 }
10910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10911 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10912 if (!SWIG_IsOK(ecode2)) {
10913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10914 }
10915 arg2 = static_cast< int >(val2);
10916 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10917 if (!SWIG_IsOK(ecode3)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10919 }
10920 arg3 = static_cast< int >(val3);
10921 {
10922 (arg1)->Scale(arg2,arg3);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_Py_Void();
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10933 int argc;
10934 PyObject *argv[4];
10935
10936 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10937 --argc;
10938 if (argc == 2) {
10939 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10940 }
10941 if (argc == 3) {
10942 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10943 }
10944
10945 fail:
10946 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxRect2D *arg1 = (wxRect2D *) 0 ;
10954 PyObject *arg2 = (PyObject *) 0 ;
10955 bool result;
10956 void *argp1 = 0 ;
10957 int res1 = 0 ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "other", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10968 }
10969 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10970 arg2 = obj1;
10971 {
10972 result = (bool)wxRect2D___eq__(arg1,arg2);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 {
10976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10977 }
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10985 PyObject *resultobj = 0;
10986 wxRect2D *arg1 = (wxRect2D *) 0 ;
10987 PyObject *arg2 = (PyObject *) 0 ;
10988 bool result;
10989 void *argp1 = 0 ;
10990 int res1 = 0 ;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 char * kwnames[] = {
10994 (char *) "self",(char *) "other", NULL
10995 };
10996
10997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10999 if (!SWIG_IsOK(res1)) {
11000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11001 }
11002 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11003 arg2 = obj1;
11004 {
11005 result = (bool)wxRect2D___ne__(arg1,arg2);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11018 PyObject *resultobj = 0;
11019 wxRect2D *arg1 = (wxRect2D *) 0 ;
11020 wxDouble arg2 ;
11021 void *argp1 = 0 ;
11022 int res1 = 0 ;
11023 void *argp2 ;
11024 int res2 = 0 ;
11025 PyObject *swig_obj[2] ;
11026
11027 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11029 if (!SWIG_IsOK(res1)) {
11030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11031 }
11032 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11033 {
11034 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11035 if (!SWIG_IsOK(res2)) {
11036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11037 }
11038 if (!argp2) {
11039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11040 } else {
11041 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11042 arg2 = *temp;
11043 if (SWIG_IsNewObj(res2)) delete temp;
11044 }
11045 }
11046 if (arg1) (arg1)->m_x = arg2;
11047
11048 resultobj = SWIG_Py_Void();
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *resultobj = 0;
11057 wxRect2D *arg1 = (wxRect2D *) 0 ;
11058 wxDouble result;
11059 void *argp1 = 0 ;
11060 int res1 = 0 ;
11061 PyObject *swig_obj[1] ;
11062
11063 if (!args) SWIG_fail;
11064 swig_obj[0] = args;
11065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11066 if (!SWIG_IsOK(res1)) {
11067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11068 }
11069 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11070 result = ((arg1)->m_x);
11071 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11079 PyObject *resultobj = 0;
11080 wxRect2D *arg1 = (wxRect2D *) 0 ;
11081 wxDouble arg2 ;
11082 void *argp1 = 0 ;
11083 int res1 = 0 ;
11084 void *argp2 ;
11085 int res2 = 0 ;
11086 PyObject *swig_obj[2] ;
11087
11088 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11090 if (!SWIG_IsOK(res1)) {
11091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11092 }
11093 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11094 {
11095 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11096 if (!SWIG_IsOK(res2)) {
11097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11098 }
11099 if (!argp2) {
11100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11101 } else {
11102 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11103 arg2 = *temp;
11104 if (SWIG_IsNewObj(res2)) delete temp;
11105 }
11106 }
11107 if (arg1) (arg1)->m_y = arg2;
11108
11109 resultobj = SWIG_Py_Void();
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11117 PyObject *resultobj = 0;
11118 wxRect2D *arg1 = (wxRect2D *) 0 ;
11119 wxDouble result;
11120 void *argp1 = 0 ;
11121 int res1 = 0 ;
11122 PyObject *swig_obj[1] ;
11123
11124 if (!args) SWIG_fail;
11125 swig_obj[0] = args;
11126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11127 if (!SWIG_IsOK(res1)) {
11128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11129 }
11130 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11131 result = ((arg1)->m_y);
11132 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxRect2D *arg1 = (wxRect2D *) 0 ;
11142 wxDouble arg2 ;
11143 void *argp1 = 0 ;
11144 int res1 = 0 ;
11145 void *argp2 ;
11146 int res2 = 0 ;
11147 PyObject *swig_obj[2] ;
11148
11149 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11153 }
11154 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11155 {
11156 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11157 if (!SWIG_IsOK(res2)) {
11158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11159 }
11160 if (!argp2) {
11161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11162 } else {
11163 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11164 arg2 = *temp;
11165 if (SWIG_IsNewObj(res2)) delete temp;
11166 }
11167 }
11168 if (arg1) (arg1)->m_width = arg2;
11169
11170 resultobj = SWIG_Py_Void();
11171 return resultobj;
11172 fail:
11173 return NULL;
11174 }
11175
11176
11177 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178 PyObject *resultobj = 0;
11179 wxRect2D *arg1 = (wxRect2D *) 0 ;
11180 wxDouble result;
11181 void *argp1 = 0 ;
11182 int res1 = 0 ;
11183 PyObject *swig_obj[1] ;
11184
11185 if (!args) SWIG_fail;
11186 swig_obj[0] = args;
11187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11188 if (!SWIG_IsOK(res1)) {
11189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11190 }
11191 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11192 result = ((arg1)->m_width);
11193 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11201 PyObject *resultobj = 0;
11202 wxRect2D *arg1 = (wxRect2D *) 0 ;
11203 wxDouble arg2 ;
11204 void *argp1 = 0 ;
11205 int res1 = 0 ;
11206 void *argp2 ;
11207 int res2 = 0 ;
11208 PyObject *swig_obj[2] ;
11209
11210 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11214 }
11215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11216 {
11217 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11218 if (!SWIG_IsOK(res2)) {
11219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11220 }
11221 if (!argp2) {
11222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11223 } else {
11224 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11225 arg2 = *temp;
11226 if (SWIG_IsNewObj(res2)) delete temp;
11227 }
11228 }
11229 if (arg1) (arg1)->m_height = arg2;
11230
11231 resultobj = SWIG_Py_Void();
11232 return resultobj;
11233 fail:
11234 return NULL;
11235 }
11236
11237
11238 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11239 PyObject *resultobj = 0;
11240 wxRect2D *arg1 = (wxRect2D *) 0 ;
11241 wxDouble result;
11242 void *argp1 = 0 ;
11243 int res1 = 0 ;
11244 PyObject *swig_obj[1] ;
11245
11246 if (!args) SWIG_fail;
11247 swig_obj[0] = args;
11248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11249 if (!SWIG_IsOK(res1)) {
11250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11251 }
11252 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11253 result = ((arg1)->m_height);
11254 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11255 return resultobj;
11256 fail:
11257 return NULL;
11258 }
11259
11260
11261 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11262 PyObject *resultobj = 0;
11263 wxRect2D *arg1 = (wxRect2D *) 0 ;
11264 wxDouble arg2 = (wxDouble) 0 ;
11265 wxDouble arg3 = (wxDouble) 0 ;
11266 wxDouble arg4 = (wxDouble) 0 ;
11267 wxDouble arg5 = (wxDouble) 0 ;
11268 void *argp1 = 0 ;
11269 int res1 = 0 ;
11270 void *argp2 ;
11271 int res2 = 0 ;
11272 void *argp3 ;
11273 int res3 = 0 ;
11274 void *argp4 ;
11275 int res4 = 0 ;
11276 void *argp5 ;
11277 int res5 = 0 ;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 PyObject * obj2 = 0 ;
11281 PyObject * obj3 = 0 ;
11282 PyObject * obj4 = 0 ;
11283 char * kwnames[] = {
11284 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11285 };
11286
11287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11289 if (!SWIG_IsOK(res1)) {
11290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11291 }
11292 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11293 if (obj1) {
11294 {
11295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11296 if (!SWIG_IsOK(res2)) {
11297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11298 }
11299 if (!argp2) {
11300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11301 } else {
11302 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11303 arg2 = *temp;
11304 if (SWIG_IsNewObj(res2)) delete temp;
11305 }
11306 }
11307 }
11308 if (obj2) {
11309 {
11310 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11311 if (!SWIG_IsOK(res3)) {
11312 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11313 }
11314 if (!argp3) {
11315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11316 } else {
11317 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11318 arg3 = *temp;
11319 if (SWIG_IsNewObj(res3)) delete temp;
11320 }
11321 }
11322 }
11323 if (obj3) {
11324 {
11325 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11326 if (!SWIG_IsOK(res4)) {
11327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11328 }
11329 if (!argp4) {
11330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11331 } else {
11332 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11333 arg4 = *temp;
11334 if (SWIG_IsNewObj(res4)) delete temp;
11335 }
11336 }
11337 }
11338 if (obj4) {
11339 {
11340 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11341 if (!SWIG_IsOK(res5)) {
11342 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11343 }
11344 if (!argp5) {
11345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11346 } else {
11347 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11348 arg5 = *temp;
11349 if (SWIG_IsNewObj(res5)) delete temp;
11350 }
11351 }
11352 }
11353 {
11354 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359 fail:
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11365 PyObject *resultobj = 0;
11366 wxRect2D *arg1 = (wxRect2D *) 0 ;
11367 PyObject *result = 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 PyObject *swig_obj[1] ;
11371
11372 if (!args) SWIG_fail;
11373 swig_obj[0] = args;
11374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11375 if (!SWIG_IsOK(res1)) {
11376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11377 }
11378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11379 {
11380 result = (PyObject *)wxRect2D_Get(arg1);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = result;
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11391 PyObject *obj;
11392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11393 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11394 return SWIG_Py_Void();
11395 }
11396
11397 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398 return SWIG_Python_InitShadowInstance(args);
11399 }
11400
11401 SWIGINTERN int DefaultPosition_set(PyObject *) {
11402 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11403 return 1;
11404 }
11405
11406
11407 SWIGINTERN PyObject *DefaultPosition_get(void) {
11408 PyObject *pyobj = 0;
11409
11410 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11411 return pyobj;
11412 }
11413
11414
11415 SWIGINTERN int DefaultSize_set(PyObject *) {
11416 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11417 return 1;
11418 }
11419
11420
11421 SWIGINTERN PyObject *DefaultSize_get(void) {
11422 PyObject *pyobj = 0;
11423
11424 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11425 return pyobj;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 PyObject *arg1 = (PyObject *) 0 ;
11432 wxPyInputStream *result = 0 ;
11433 PyObject * obj0 = 0 ;
11434 char * kwnames[] = {
11435 (char *) "p", NULL
11436 };
11437
11438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11439 arg1 = obj0;
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11447 return resultobj;
11448 fail:
11449 return NULL;
11450 }
11451
11452
11453 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 PyObject *resultobj = 0;
11455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 PyObject *swig_obj[1] ;
11459
11460 if (!args) SWIG_fail;
11461 swig_obj[0] = args;
11462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11463 if (!SWIG_IsOK(res1)) {
11464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11465 }
11466 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 delete arg1;
11470
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 resultobj = SWIG_Py_Void();
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482 PyObject *resultobj = 0;
11483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11484 void *argp1 = 0 ;
11485 int res1 = 0 ;
11486 PyObject *swig_obj[1] ;
11487
11488 if (!args) SWIG_fail;
11489 swig_obj[0] = args;
11490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11491 if (!SWIG_IsOK(res1)) {
11492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11493 }
11494 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 (arg1)->close();
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 resultobj = SWIG_Py_Void();
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11509 PyObject *resultobj = 0;
11510 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 PyObject *swig_obj[1] ;
11514
11515 if (!args) SWIG_fail;
11516 swig_obj[0] = args;
11517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11520 }
11521 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 (arg1)->flush();
11525 wxPyEndAllowThreads(__tstate);
11526 if (PyErr_Occurred()) SWIG_fail;
11527 }
11528 resultobj = SWIG_Py_Void();
11529 return resultobj;
11530 fail:
11531 return NULL;
11532 }
11533
11534
11535 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11536 PyObject *resultobj = 0;
11537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11538 bool result;
11539 void *argp1 = 0 ;
11540 int res1 = 0 ;
11541 PyObject *swig_obj[1] ;
11542
11543 if (!args) SWIG_fail;
11544 swig_obj[0] = args;
11545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11546 if (!SWIG_IsOK(res1)) {
11547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11548 }
11549 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (bool)(arg1)->eof();
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11558 }
11559 return resultobj;
11560 fail:
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11568 int arg2 = (int) -1 ;
11569 PyObject *result = 0 ;
11570 void *argp1 = 0 ;
11571 int res1 = 0 ;
11572 int val2 ;
11573 int ecode2 = 0 ;
11574 PyObject * obj0 = 0 ;
11575 PyObject * obj1 = 0 ;
11576 char * kwnames[] = {
11577 (char *) "self",(char *) "size", NULL
11578 };
11579
11580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11582 if (!SWIG_IsOK(res1)) {
11583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11584 }
11585 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11586 if (obj1) {
11587 ecode2 = SWIG_AsVal_int(obj1, &val2);
11588 if (!SWIG_IsOK(ecode2)) {
11589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11590 }
11591 arg2 = static_cast< int >(val2);
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (PyObject *)(arg1)->read(arg2);
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = result;
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11607 PyObject *resultobj = 0;
11608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11609 int arg2 = (int) -1 ;
11610 PyObject *result = 0 ;
11611 void *argp1 = 0 ;
11612 int res1 = 0 ;
11613 int val2 ;
11614 int ecode2 = 0 ;
11615 PyObject * obj0 = 0 ;
11616 PyObject * obj1 = 0 ;
11617 char * kwnames[] = {
11618 (char *) "self",(char *) "size", NULL
11619 };
11620
11621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11623 if (!SWIG_IsOK(res1)) {
11624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11625 }
11626 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11627 if (obj1) {
11628 ecode2 = SWIG_AsVal_int(obj1, &val2);
11629 if (!SWIG_IsOK(ecode2)) {
11630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11631 }
11632 arg2 = static_cast< int >(val2);
11633 }
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (PyObject *)(arg1)->readline(arg2);
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 resultobj = result;
11641 return resultobj;
11642 fail:
11643 return NULL;
11644 }
11645
11646
11647 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11648 PyObject *resultobj = 0;
11649 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11650 int arg2 = (int) -1 ;
11651 PyObject *result = 0 ;
11652 void *argp1 = 0 ;
11653 int res1 = 0 ;
11654 int val2 ;
11655 int ecode2 = 0 ;
11656 PyObject * obj0 = 0 ;
11657 PyObject * obj1 = 0 ;
11658 char * kwnames[] = {
11659 (char *) "self",(char *) "sizehint", NULL
11660 };
11661
11662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11664 if (!SWIG_IsOK(res1)) {
11665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11666 }
11667 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11668 if (obj1) {
11669 ecode2 = SWIG_AsVal_int(obj1, &val2);
11670 if (!SWIG_IsOK(ecode2)) {
11671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11672 }
11673 arg2 = static_cast< int >(val2);
11674 }
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = (PyObject *)(arg1)->readlines(arg2);
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 resultobj = result;
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11691 int arg2 ;
11692 int arg3 = (int) 0 ;
11693 void *argp1 = 0 ;
11694 int res1 = 0 ;
11695 int val2 ;
11696 int ecode2 = 0 ;
11697 int val3 ;
11698 int ecode3 = 0 ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char * kwnames[] = {
11703 (char *) "self",(char *) "offset",(char *) "whence", NULL
11704 };
11705
11706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11710 }
11711 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11712 ecode2 = SWIG_AsVal_int(obj1, &val2);
11713 if (!SWIG_IsOK(ecode2)) {
11714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11715 }
11716 arg2 = static_cast< int >(val2);
11717 if (obj2) {
11718 ecode3 = SWIG_AsVal_int(obj2, &val3);
11719 if (!SWIG_IsOK(ecode3)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11721 }
11722 arg3 = static_cast< int >(val3);
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 (arg1)->seek(arg2,arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 resultobj = SWIG_Py_Void();
11731 return resultobj;
11732 fail:
11733 return NULL;
11734 }
11735
11736
11737 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11740 int result;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 PyObject *swig_obj[1] ;
11744
11745 if (!args) SWIG_fail;
11746 swig_obj[0] = args;
11747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11750 }
11751 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (int)(arg1)->tell();
11755 wxPyEndAllowThreads(__tstate);
11756 if (PyErr_Occurred()) SWIG_fail;
11757 }
11758 resultobj = SWIG_From_int(static_cast< int >(result));
11759 return resultobj;
11760 fail:
11761 return NULL;
11762 }
11763
11764
11765 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11766 PyObject *resultobj = 0;
11767 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11768 char result;
11769 void *argp1 = 0 ;
11770 int res1 = 0 ;
11771 PyObject *swig_obj[1] ;
11772
11773 if (!args) SWIG_fail;
11774 swig_obj[0] = args;
11775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11776 if (!SWIG_IsOK(res1)) {
11777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11778 }
11779 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (char)(arg1)->Peek();
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 resultobj = SWIG_From_char(static_cast< char >(result));
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11796 char result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11806 }
11807 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (char)(arg1)->GetC();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_From_char(static_cast< char >(result));
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11822 PyObject *resultobj = 0;
11823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11824 size_t result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 PyObject *swig_obj[1] ;
11828
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11834 }
11835 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (size_t)(arg1)->LastRead();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11852 bool result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11862 }
11863 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (bool)(arg1)->CanRead();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11872 }
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11880 PyObject *resultobj = 0;
11881 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11882 bool result;
11883 void *argp1 = 0 ;
11884 int res1 = 0 ;
11885 PyObject *swig_obj[1] ;
11886
11887 if (!args) SWIG_fail;
11888 swig_obj[0] = args;
11889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11890 if (!SWIG_IsOK(res1)) {
11891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11892 }
11893 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->Eof();
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11902 }
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj = 0;
11911 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11912 char arg2 ;
11913 bool result;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 char val2 ;
11917 int ecode2 = 0 ;
11918 PyObject * obj0 = 0 ;
11919 PyObject * obj1 = 0 ;
11920 char * kwnames[] = {
11921 (char *) "self",(char *) "c", NULL
11922 };
11923
11924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11926 if (!SWIG_IsOK(res1)) {
11927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11928 }
11929 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11930 ecode2 = SWIG_AsVal_char(obj1, &val2);
11931 if (!SWIG_IsOK(ecode2)) {
11932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11933 }
11934 arg2 = static_cast< char >(val2);
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (bool)(arg1)->Ungetch(arg2);
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj = 0;
11952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11953 long arg2 ;
11954 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11955 long result;
11956 void *argp1 = 0 ;
11957 int res1 = 0 ;
11958 long val2 ;
11959 int ecode2 = 0 ;
11960 int val3 ;
11961 int ecode3 = 0 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 PyObject * obj2 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "pos",(char *) "mode", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11973 }
11974 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11975 ecode2 = SWIG_AsVal_long(obj1, &val2);
11976 if (!SWIG_IsOK(ecode2)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11978 }
11979 arg2 = static_cast< long >(val2);
11980 if (obj2) {
11981 ecode3 = SWIG_AsVal_int(obj2, &val3);
11982 if (!SWIG_IsOK(ecode3)) {
11983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11984 }
11985 arg3 = static_cast< wxSeekMode >(val3);
11986 }
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (long)(arg1)->SeekI(arg2,arg3);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_From_long(static_cast< long >(result));
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 PyObject *resultobj = 0;
12002 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12003 long result;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 PyObject *swig_obj[1] ;
12007
12008 if (!args) SWIG_fail;
12009 swig_obj[0] = args;
12010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12011 if (!SWIG_IsOK(res1)) {
12012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12013 }
12014 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (long)(arg1)->TellI();
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 resultobj = SWIG_From_long(static_cast< long >(result));
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029 PyObject *obj;
12030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12031 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12032 return SWIG_Py_Void();
12033 }
12034
12035 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12036 return SWIG_Python_InitShadowInstance(args);
12037 }
12038
12039 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12040 PyObject *resultobj = 0;
12041 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12042 PyObject *arg2 = (PyObject *) 0 ;
12043 void *argp1 = 0 ;
12044 int res1 = 0 ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 char * kwnames[] = {
12048 (char *) "self",(char *) "obj", NULL
12049 };
12050
12051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12053 if (!SWIG_IsOK(res1)) {
12054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12055 }
12056 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12057 arg2 = obj1;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 wxOutputStream_write(arg1,arg2);
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_Py_Void();
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12072 PyObject *resultobj = 0;
12073 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12074 size_t result;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 PyObject *swig_obj[1] ;
12078
12079 if (!args) SWIG_fail;
12080 swig_obj[0] = args;
12081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12082 if (!SWIG_IsOK(res1)) {
12083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12084 }
12085 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12100 PyObject *obj;
12101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12102 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12103 return SWIG_Py_Void();
12104 }
12105
12106 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj = 0;
12108 wxInputStream *arg1 = (wxInputStream *) 0 ;
12109 wxString *arg2 = 0 ;
12110 wxString *arg3 = 0 ;
12111 wxString *arg4 = 0 ;
12112 wxDateTime arg5 ;
12113 wxFSFile *result = 0 ;
12114 wxPyInputStream *temp1 ;
12115 bool temp2 = false ;
12116 bool temp3 = false ;
12117 bool temp4 = false ;
12118 void *argp5 ;
12119 int res5 = 0 ;
12120 PyObject * obj0 = 0 ;
12121 PyObject * obj1 = 0 ;
12122 PyObject * obj2 = 0 ;
12123 PyObject * obj3 = 0 ;
12124 PyObject * obj4 = 0 ;
12125 char * kwnames[] = {
12126 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12127 };
12128
12129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12130 {
12131 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12132 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12133 } else {
12134 PyErr_Clear(); // clear the failure of the wxPyConvert above
12135 arg1 = wxPyCBInputStream_create(obj0, true);
12136 if (arg1 == NULL) {
12137 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12138 SWIG_fail;
12139 }
12140 }
12141 }
12142 {
12143 arg2 = wxString_in_helper(obj1);
12144 if (arg2 == NULL) SWIG_fail;
12145 temp2 = true;
12146 }
12147 {
12148 arg3 = wxString_in_helper(obj2);
12149 if (arg3 == NULL) SWIG_fail;
12150 temp3 = true;
12151 }
12152 {
12153 arg4 = wxString_in_helper(obj3);
12154 if (arg4 == NULL) SWIG_fail;
12155 temp4 = true;
12156 }
12157 {
12158 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12159 if (!SWIG_IsOK(res5)) {
12160 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12161 }
12162 if (!argp5) {
12163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12164 } else {
12165 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12166 arg5 = *temp;
12167 if (SWIG_IsNewObj(res5)) delete temp;
12168 }
12169 }
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12177 {
12178 if (temp2)
12179 delete arg2;
12180 }
12181 {
12182 if (temp3)
12183 delete arg3;
12184 }
12185 {
12186 if (temp4)
12187 delete arg4;
12188 }
12189 return resultobj;
12190 fail:
12191 {
12192 if (temp2)
12193 delete arg2;
12194 }
12195 {
12196 if (temp3)
12197 delete arg3;
12198 }
12199 {
12200 if (temp4)
12201 delete arg4;
12202 }
12203 return NULL;
12204 }
12205
12206
12207 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208 PyObject *resultobj = 0;
12209 wxFSFile *arg1 = (wxFSFile *) 0 ;
12210 void *argp1 = 0 ;
12211 int res1 = 0 ;
12212 PyObject *swig_obj[1] ;
12213
12214 if (!args) SWIG_fail;
12215 swig_obj[0] = args;
12216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12217 if (!SWIG_IsOK(res1)) {
12218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12219 }
12220 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 delete arg1;
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 resultobj = SWIG_Py_Void();
12229 return resultobj;
12230 fail:
12231 return NULL;
12232 }
12233
12234
12235 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12236 PyObject *resultobj = 0;
12237 wxFSFile *arg1 = (wxFSFile *) 0 ;
12238 wxInputStream *result = 0 ;
12239 void *argp1 = 0 ;
12240 int res1 = 0 ;
12241 PyObject *swig_obj[1] ;
12242
12243 if (!args) SWIG_fail;
12244 swig_obj[0] = args;
12245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12246 if (!SWIG_IsOK(res1)) {
12247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12248 }
12249 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (wxInputStream *)(arg1)->GetStream();
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 wxPyInputStream * _ptr = NULL;
12258
12259 if (result) {
12260 _ptr = new wxPyInputStream(result);
12261 }
12262 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12263 }
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12271 PyObject *resultobj = 0;
12272 wxFSFile *arg1 = (wxFSFile *) 0 ;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 PyObject *swig_obj[1] ;
12276
12277 if (!args) SWIG_fail;
12278 swig_obj[0] = args;
12279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12280 if (!SWIG_IsOK(res1)) {
12281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12282 }
12283 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 (arg1)->DetachStream();
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_Py_Void();
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12298 PyObject *resultobj = 0;
12299 wxFSFile *arg1 = (wxFSFile *) 0 ;
12300 wxString *result = 0 ;
12301 void *argp1 = 0 ;
12302 int res1 = 0 ;
12303 PyObject *swig_obj[1] ;
12304
12305 if (!args) SWIG_fail;
12306 swig_obj[0] = args;
12307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12308 if (!SWIG_IsOK(res1)) {
12309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12310 }
12311 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 {
12315 wxString const &_result_ref = (arg1)->GetMimeType();
12316 result = (wxString *) &_result_ref;
12317 }
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 #if wxUSE_UNICODE
12323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12324 #else
12325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12326 #endif
12327 }
12328 return resultobj;
12329 fail:
12330 return NULL;
12331 }
12332
12333
12334 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12335 PyObject *resultobj = 0;
12336 wxFSFile *arg1 = (wxFSFile *) 0 ;
12337 wxString *result = 0 ;
12338 void *argp1 = 0 ;
12339 int res1 = 0 ;
12340 PyObject *swig_obj[1] ;
12341
12342 if (!args) SWIG_fail;
12343 swig_obj[0] = args;
12344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12345 if (!SWIG_IsOK(res1)) {
12346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12347 }
12348 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 {
12352 wxString const &_result_ref = (arg1)->GetLocation();
12353 result = (wxString *) &_result_ref;
12354 }
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 #if wxUSE_UNICODE
12360 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12361 #else
12362 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12363 #endif
12364 }
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12372 PyObject *resultobj = 0;
12373 wxFSFile *arg1 = (wxFSFile *) 0 ;
12374 wxString *result = 0 ;
12375 void *argp1 = 0 ;
12376 int res1 = 0 ;
12377 PyObject *swig_obj[1] ;
12378
12379 if (!args) SWIG_fail;
12380 swig_obj[0] = args;
12381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12382 if (!SWIG_IsOK(res1)) {
12383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12384 }
12385 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 {
12389 wxString const &_result_ref = (arg1)->GetAnchor();
12390 result = (wxString *) &_result_ref;
12391 }
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 #if wxUSE_UNICODE
12397 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12398 #else
12399 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12400 #endif
12401 }
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409 PyObject *resultobj = 0;
12410 wxFSFile *arg1 = (wxFSFile *) 0 ;
12411 wxDateTime result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 PyObject *swig_obj[1] ;
12415
12416 if (!args) SWIG_fail;
12417 swig_obj[0] = args;
12418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12419 if (!SWIG_IsOK(res1)) {
12420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12421 }
12422 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 result = (arg1)->GetModificationTime();
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12437 PyObject *obj;
12438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12439 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12440 return SWIG_Py_Void();
12441 }
12442
12443 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 return SWIG_Python_InitShadowInstance(args);
12445 }
12446
12447 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12448 PyObject *resultobj = 0;
12449 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12450 void *argp1 = 0 ;
12451 int res1 = 0 ;
12452 PyObject *swig_obj[1] ;
12453
12454 if (!args) SWIG_fail;
12455 swig_obj[0] = args;
12456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12457 if (!SWIG_IsOK(res1)) {
12458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12459 }
12460 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 delete arg1;
12464
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_Py_Void();
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12476 PyObject *obj;
12477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12478 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12479 return SWIG_Py_Void();
12480 }
12481
12482 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12483 PyObject *resultobj = 0;
12484 wxPyFileSystemHandler *result = 0 ;
12485
12486 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12487 {
12488 PyThreadState* __tstate = wxPyBeginAllowThreads();
12489 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12494 return resultobj;
12495 fail:
12496 return NULL;
12497 }
12498
12499
12500 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj = 0;
12502 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12503 PyObject *arg2 = (PyObject *) 0 ;
12504 PyObject *arg3 = (PyObject *) 0 ;
12505 void *argp1 = 0 ;
12506 int res1 = 0 ;
12507 PyObject * obj0 = 0 ;
12508 PyObject * obj1 = 0 ;
12509 PyObject * obj2 = 0 ;
12510 char * kwnames[] = {
12511 (char *) "self",(char *) "self",(char *) "_class", NULL
12512 };
12513
12514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12516 if (!SWIG_IsOK(res1)) {
12517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12518 }
12519 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12520 arg2 = obj1;
12521 arg3 = obj2;
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 (arg1)->_setCallbackInfo(arg2,arg3);
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 resultobj = SWIG_Py_Void();
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj = 0;
12537 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12538 wxString *arg2 = 0 ;
12539 bool result;
12540 void *argp1 = 0 ;
12541 int res1 = 0 ;
12542 bool temp2 = false ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 char * kwnames[] = {
12546 (char *) "self",(char *) "location", NULL
12547 };
12548
12549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12551 if (!SWIG_IsOK(res1)) {
12552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12553 }
12554 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12555 {
12556 arg2 = wxString_in_helper(obj1);
12557 if (arg2 == NULL) SWIG_fail;
12558 temp2 = true;
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 {
12570 if (temp2)
12571 delete arg2;
12572 }
12573 return resultobj;
12574 fail:
12575 {
12576 if (temp2)
12577 delete arg2;
12578 }
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12586 wxFileSystem *arg2 = 0 ;
12587 wxString *arg3 = 0 ;
12588 wxFSFile *result = 0 ;
12589 void *argp1 = 0 ;
12590 int res1 = 0 ;
12591 void *argp2 = 0 ;
12592 int res2 = 0 ;
12593 bool temp3 = false ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 PyObject * obj2 = 0 ;
12597 char * kwnames[] = {
12598 (char *) "self",(char *) "fs",(char *) "location", NULL
12599 };
12600
12601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12605 }
12606 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12608 if (!SWIG_IsOK(res2)) {
12609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12610 }
12611 if (!argp2) {
12612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12613 }
12614 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12615 {
12616 arg3 = wxString_in_helper(obj2);
12617 if (arg3 == NULL) SWIG_fail;
12618 temp3 = true;
12619 }
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 {
12627 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12628 }
12629 {
12630 if (temp3)
12631 delete arg3;
12632 }
12633 return resultobj;
12634 fail:
12635 {
12636 if (temp3)
12637 delete arg3;
12638 }
12639 return NULL;
12640 }
12641
12642
12643 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj = 0;
12645 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12646 wxString *arg2 = 0 ;
12647 int arg3 = (int) 0 ;
12648 wxString result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 bool temp2 = false ;
12652 int val3 ;
12653 int ecode3 = 0 ;
12654 PyObject * obj0 = 0 ;
12655 PyObject * obj1 = 0 ;
12656 PyObject * obj2 = 0 ;
12657 char * kwnames[] = {
12658 (char *) "self",(char *) "spec",(char *) "flags", NULL
12659 };
12660
12661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12663 if (!SWIG_IsOK(res1)) {
12664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12665 }
12666 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12667 {
12668 arg2 = wxString_in_helper(obj1);
12669 if (arg2 == NULL) SWIG_fail;
12670 temp2 = true;
12671 }
12672 if (obj2) {
12673 ecode3 = SWIG_AsVal_int(obj2, &val3);
12674 if (!SWIG_IsOK(ecode3)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12676 }
12677 arg3 = static_cast< int >(val3);
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 #if wxUSE_UNICODE
12687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12688 #else
12689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12690 #endif
12691 }
12692 {
12693 if (temp2)
12694 delete arg2;
12695 }
12696 return resultobj;
12697 fail:
12698 {
12699 if (temp2)
12700 delete arg2;
12701 }
12702 return NULL;
12703 }
12704
12705
12706 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12707 PyObject *resultobj = 0;
12708 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12709 wxString result;
12710 void *argp1 = 0 ;
12711 int res1 = 0 ;
12712 PyObject *swig_obj[1] ;
12713
12714 if (!args) SWIG_fail;
12715 swig_obj[0] = args;
12716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12717 if (!SWIG_IsOK(res1)) {
12718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12719 }
12720 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 result = (arg1)->FindNext();
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 {
12728 #if wxUSE_UNICODE
12729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12730 #else
12731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12732 #endif
12733 }
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj = 0;
12742 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12743 wxString *arg2 = 0 ;
12744 wxString result;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 bool temp2 = false ;
12748 PyObject * obj0 = 0 ;
12749 PyObject * obj1 = 0 ;
12750 char * kwnames[] = {
12751 (char *) "self",(char *) "location", NULL
12752 };
12753
12754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12756 if (!SWIG_IsOK(res1)) {
12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12758 }
12759 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12760 {
12761 arg2 = wxString_in_helper(obj1);
12762 if (arg2 == NULL) SWIG_fail;
12763 temp2 = true;
12764 }
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (arg1)->GetProtocol((wxString const &)*arg2);
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 #if wxUSE_UNICODE
12773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12774 #else
12775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12776 #endif
12777 }
12778 {
12779 if (temp2)
12780 delete arg2;
12781 }
12782 return resultobj;
12783 fail:
12784 {
12785 if (temp2)
12786 delete arg2;
12787 }
12788 return NULL;
12789 }
12790
12791
12792 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj = 0;
12794 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12795 wxString *arg2 = 0 ;
12796 wxString result;
12797 void *argp1 = 0 ;
12798 int res1 = 0 ;
12799 bool temp2 = false ;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 char * kwnames[] = {
12803 (char *) "self",(char *) "location", NULL
12804 };
12805
12806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12810 }
12811 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12812 {
12813 arg2 = wxString_in_helper(obj1);
12814 if (arg2 == NULL) SWIG_fail;
12815 temp2 = true;
12816 }
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 {
12824 #if wxUSE_UNICODE
12825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12826 #else
12827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12828 #endif
12829 }
12830 {
12831 if (temp2)
12832 delete arg2;
12833 }
12834 return resultobj;
12835 fail:
12836 {
12837 if (temp2)
12838 delete arg2;
12839 }
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12845 PyObject *resultobj = 0;
12846 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12847 wxString *arg2 = 0 ;
12848 wxString result;
12849 void *argp1 = 0 ;
12850 int res1 = 0 ;
12851 bool temp2 = false ;
12852 PyObject * obj0 = 0 ;
12853 PyObject * obj1 = 0 ;
12854 char * kwnames[] = {
12855 (char *) "self",(char *) "location", NULL
12856 };
12857
12858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12860 if (!SWIG_IsOK(res1)) {
12861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12862 }
12863 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12864 {
12865 arg2 = wxString_in_helper(obj1);
12866 if (arg2 == NULL) SWIG_fail;
12867 temp2 = true;
12868 }
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 result = (arg1)->GetAnchor((wxString const &)*arg2);
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 {
12876 #if wxUSE_UNICODE
12877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12878 #else
12879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12880 #endif
12881 }
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 return resultobj;
12887 fail:
12888 {
12889 if (temp2)
12890 delete arg2;
12891 }
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12897 PyObject *resultobj = 0;
12898 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12899 wxString *arg2 = 0 ;
12900 wxString result;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 bool temp2 = false ;
12904 PyObject * obj0 = 0 ;
12905 PyObject * obj1 = 0 ;
12906 char * kwnames[] = {
12907 (char *) "self",(char *) "location", NULL
12908 };
12909
12910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12912 if (!SWIG_IsOK(res1)) {
12913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12914 }
12915 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12916 {
12917 arg2 = wxString_in_helper(obj1);
12918 if (arg2 == NULL) SWIG_fail;
12919 temp2 = true;
12920 }
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928 #if wxUSE_UNICODE
12929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12930 #else
12931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12932 #endif
12933 }
12934 {
12935 if (temp2)
12936 delete arg2;
12937 }
12938 return resultobj;
12939 fail:
12940 {
12941 if (temp2)
12942 delete arg2;
12943 }
12944 return NULL;
12945 }
12946
12947
12948 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = 0;
12950 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12951 wxString *arg2 = 0 ;
12952 wxString result;
12953 void *argp1 = 0 ;
12954 int res1 = 0 ;
12955 bool temp2 = false ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 char * kwnames[] = {
12959 (char *) "self",(char *) "location", NULL
12960 };
12961
12962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12964 if (!SWIG_IsOK(res1)) {
12965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12966 }
12967 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12968 {
12969 arg2 = wxString_in_helper(obj1);
12970 if (arg2 == NULL) SWIG_fail;
12971 temp2 = true;
12972 }
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 {
12980 #if wxUSE_UNICODE
12981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12982 #else
12983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12984 #endif
12985 }
12986 {
12987 if (temp2)
12988 delete arg2;
12989 }
12990 return resultobj;
12991 fail:
12992 {
12993 if (temp2)
12994 delete arg2;
12995 }
12996 return NULL;
12997 }
12998
12999
13000 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13001 PyObject *obj;
13002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13003 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13004 return SWIG_Py_Void();
13005 }
13006
13007 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 return SWIG_Python_InitShadowInstance(args);
13009 }
13010
13011 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13012 PyObject *resultobj = 0;
13013 wxFileSystem *result = 0 ;
13014
13015 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (wxFileSystem *)new wxFileSystem();
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13030 PyObject *resultobj = 0;
13031 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13032 void *argp1 = 0 ;
13033 int res1 = 0 ;
13034 PyObject *swig_obj[1] ;
13035
13036 if (!args) SWIG_fail;
13037 swig_obj[0] = args;
13038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13039 if (!SWIG_IsOK(res1)) {
13040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13041 }
13042 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 delete arg1;
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 resultobj = SWIG_Py_Void();
13051 return resultobj;
13052 fail:
13053 return NULL;
13054 }
13055
13056
13057 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj = 0;
13059 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13060 wxString *arg2 = 0 ;
13061 bool arg3 = (bool) false ;
13062 void *argp1 = 0 ;
13063 int res1 = 0 ;
13064 bool temp2 = false ;
13065 bool val3 ;
13066 int ecode3 = 0 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 PyObject * obj2 = 0 ;
13070 char * kwnames[] = {
13071 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13072 };
13073
13074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13076 if (!SWIG_IsOK(res1)) {
13077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13078 }
13079 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13080 {
13081 arg2 = wxString_in_helper(obj1);
13082 if (arg2 == NULL) SWIG_fail;
13083 temp2 = true;
13084 }
13085 if (obj2) {
13086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13087 if (!SWIG_IsOK(ecode3)) {
13088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13089 }
13090 arg3 = static_cast< bool >(val3);
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_Py_Void();
13099 {
13100 if (temp2)
13101 delete arg2;
13102 }
13103 return resultobj;
13104 fail:
13105 {
13106 if (temp2)
13107 delete arg2;
13108 }
13109 return NULL;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 PyObject *resultobj = 0;
13115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13116 wxString result;
13117 void *argp1 = 0 ;
13118 int res1 = 0 ;
13119 PyObject *swig_obj[1] ;
13120
13121 if (!args) SWIG_fail;
13122 swig_obj[0] = args;
13123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13124 if (!SWIG_IsOK(res1)) {
13125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13126 }
13127 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13128 {
13129 PyThreadState* __tstate = wxPyBeginAllowThreads();
13130 result = (arg1)->GetPath();
13131 wxPyEndAllowThreads(__tstate);
13132 if (PyErr_Occurred()) SWIG_fail;
13133 }
13134 {
13135 #if wxUSE_UNICODE
13136 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13137 #else
13138 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13139 #endif
13140 }
13141 return resultobj;
13142 fail:
13143 return NULL;
13144 }
13145
13146
13147 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj = 0;
13149 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13150 wxString *arg2 = 0 ;
13151 wxFSFile *result = 0 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 bool temp2 = false ;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 char * kwnames[] = {
13158 (char *) "self",(char *) "location", NULL
13159 };
13160
13161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13163 if (!SWIG_IsOK(res1)) {
13164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13165 }
13166 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13167 {
13168 arg2 = wxString_in_helper(obj1);
13169 if (arg2 == NULL) SWIG_fail;
13170 temp2 = true;
13171 }
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13180 }
13181 {
13182 if (temp2)
13183 delete arg2;
13184 }
13185 return resultobj;
13186 fail:
13187 {
13188 if (temp2)
13189 delete arg2;
13190 }
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13198 wxString *arg2 = 0 ;
13199 int arg3 = (int) 0 ;
13200 wxString result;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 bool temp2 = false ;
13204 int val3 ;
13205 int ecode3 = 0 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 PyObject * obj2 = 0 ;
13209 char * kwnames[] = {
13210 (char *) "self",(char *) "spec",(char *) "flags", NULL
13211 };
13212
13213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13215 if (!SWIG_IsOK(res1)) {
13216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13217 }
13218 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13219 {
13220 arg2 = wxString_in_helper(obj1);
13221 if (arg2 == NULL) SWIG_fail;
13222 temp2 = true;
13223 }
13224 if (obj2) {
13225 ecode3 = SWIG_AsVal_int(obj2, &val3);
13226 if (!SWIG_IsOK(ecode3)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13228 }
13229 arg3 = static_cast< int >(val3);
13230 }
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238 #if wxUSE_UNICODE
13239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13240 #else
13241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13242 #endif
13243 }
13244 {
13245 if (temp2)
13246 delete arg2;
13247 }
13248 return resultobj;
13249 fail:
13250 {
13251 if (temp2)
13252 delete arg2;
13253 }
13254 return NULL;
13255 }
13256
13257
13258 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13259 PyObject *resultobj = 0;
13260 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13261 wxString result;
13262 void *argp1 = 0 ;
13263 int res1 = 0 ;
13264 PyObject *swig_obj[1] ;
13265
13266 if (!args) SWIG_fail;
13267 swig_obj[0] = args;
13268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13269 if (!SWIG_IsOK(res1)) {
13270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13271 }
13272 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = (arg1)->FindNext();
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 {
13280 #if wxUSE_UNICODE
13281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13282 #else
13283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13284 #endif
13285 }
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj = 0;
13294 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13295 int res1 = 0 ;
13296 PyObject * obj0 = 0 ;
13297 char * kwnames[] = {
13298 (char *) "handler", NULL
13299 };
13300
13301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13302 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13303 if (!SWIG_IsOK(res1)) {
13304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 wxFileSystem::AddHandler(arg1);
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_Py_Void();
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = 0;
13321 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13322 wxFileSystemHandler *result = 0 ;
13323 void *argp1 = 0 ;
13324 int res1 = 0 ;
13325 PyObject * obj0 = 0 ;
13326 char * kwnames[] = {
13327 (char *) "handler", NULL
13328 };
13329
13330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13332 if (!SWIG_IsOK(res1)) {
13333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13334 }
13335 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13350 PyObject *resultobj = 0;
13351
13352 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 wxFileSystem::CleanUpHandlers();
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 resultobj = SWIG_Py_Void();
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj = 0;
13368 wxString *arg1 = 0 ;
13369 wxString result;
13370 bool temp1 = false ;
13371 PyObject * obj0 = 0 ;
13372 char * kwnames[] = {
13373 (char *) "filename", NULL
13374 };
13375
13376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13377 {
13378 arg1 = wxString_in_helper(obj0);
13379 if (arg1 == NULL) SWIG_fail;
13380 temp1 = true;
13381 }
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 #if wxUSE_UNICODE
13390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13391 #else
13392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13393 #endif
13394 }
13395 {
13396 if (temp1)
13397 delete arg1;
13398 }
13399 return resultobj;
13400 fail:
13401 {
13402 if (temp1)
13403 delete arg1;
13404 }
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj = 0;
13411 wxString *arg1 = 0 ;
13412 wxString result;
13413 bool temp1 = false ;
13414 PyObject * obj0 = 0 ;
13415 char * kwnames[] = {
13416 (char *) "url", NULL
13417 };
13418
13419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13420 {
13421 arg1 = wxString_in_helper(obj0);
13422 if (arg1 == NULL) SWIG_fail;
13423 temp1 = true;
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 {
13432 #if wxUSE_UNICODE
13433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13434 #else
13435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13436 #endif
13437 }
13438 {
13439 if (temp1)
13440 delete arg1;
13441 }
13442 return resultobj;
13443 fail:
13444 {
13445 if (temp1)
13446 delete arg1;
13447 }
13448 return NULL;
13449 }
13450
13451
13452 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453 PyObject *obj;
13454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13455 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13456 return SWIG_Py_Void();
13457 }
13458
13459 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13460 return SWIG_Python_InitShadowInstance(args);
13461 }
13462
13463 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13464 PyObject *resultobj = 0;
13465 wxInternetFSHandler *result = 0 ;
13466
13467 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13468 {
13469 PyThreadState* __tstate = wxPyBeginAllowThreads();
13470 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13471 wxPyEndAllowThreads(__tstate);
13472 if (PyErr_Occurred()) SWIG_fail;
13473 }
13474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = 0;
13483 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13484 wxString *arg2 = 0 ;
13485 bool result;
13486 void *argp1 = 0 ;
13487 int res1 = 0 ;
13488 bool temp2 = false ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 char * kwnames[] = {
13492 (char *) "self",(char *) "location", NULL
13493 };
13494
13495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13497 if (!SWIG_IsOK(res1)) {
13498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13499 }
13500 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13501 {
13502 arg2 = wxString_in_helper(obj1);
13503 if (arg2 == NULL) SWIG_fail;
13504 temp2 = true;
13505 }
13506 {
13507 PyThreadState* __tstate = wxPyBeginAllowThreads();
13508 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 {
13513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13514 }
13515 {
13516 if (temp2)
13517 delete arg2;
13518 }
13519 return resultobj;
13520 fail:
13521 {
13522 if (temp2)
13523 delete arg2;
13524 }
13525 return NULL;
13526 }
13527
13528
13529 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj = 0;
13531 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13532 wxFileSystem *arg2 = 0 ;
13533 wxString *arg3 = 0 ;
13534 wxFSFile *result = 0 ;
13535 void *argp1 = 0 ;
13536 int res1 = 0 ;
13537 void *argp2 = 0 ;
13538 int res2 = 0 ;
13539 bool temp3 = false ;
13540 PyObject * obj0 = 0 ;
13541 PyObject * obj1 = 0 ;
13542 PyObject * obj2 = 0 ;
13543 char * kwnames[] = {
13544 (char *) "self",(char *) "fs",(char *) "location", NULL
13545 };
13546
13547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13549 if (!SWIG_IsOK(res1)) {
13550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13551 }
13552 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13553 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13554 if (!SWIG_IsOK(res2)) {
13555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13556 }
13557 if (!argp2) {
13558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13559 }
13560 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13561 {
13562 arg3 = wxString_in_helper(obj2);
13563 if (arg3 == NULL) SWIG_fail;
13564 temp3 = true;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
13573 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13574 }
13575 {
13576 if (temp3)
13577 delete arg3;
13578 }
13579 return resultobj;
13580 fail:
13581 {
13582 if (temp3)
13583 delete arg3;
13584 }
13585 return NULL;
13586 }
13587
13588
13589 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13590 PyObject *obj;
13591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13592 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13593 return SWIG_Py_Void();
13594 }
13595
13596 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13597 return SWIG_Python_InitShadowInstance(args);
13598 }
13599
13600 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13601 PyObject *resultobj = 0;
13602 wxZipFSHandler *result = 0 ;
13603
13604 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (wxZipFSHandler *)new wxZipFSHandler();
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj = 0;
13620 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13621 wxString *arg2 = 0 ;
13622 bool result;
13623 void *argp1 = 0 ;
13624 int res1 = 0 ;
13625 bool temp2 = false ;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 char * kwnames[] = {
13629 (char *) "self",(char *) "location", NULL
13630 };
13631
13632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13634 if (!SWIG_IsOK(res1)) {
13635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13636 }
13637 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13638 {
13639 arg2 = wxString_in_helper(obj1);
13640 if (arg2 == NULL) SWIG_fail;
13641 temp2 = true;
13642 }
13643 {
13644 PyThreadState* __tstate = wxPyBeginAllowThreads();
13645 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 {
13653 if (temp2)
13654 delete arg2;
13655 }
13656 return resultobj;
13657 fail:
13658 {
13659 if (temp2)
13660 delete arg2;
13661 }
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13669 wxFileSystem *arg2 = 0 ;
13670 wxString *arg3 = 0 ;
13671 wxFSFile *result = 0 ;
13672 void *argp1 = 0 ;
13673 int res1 = 0 ;
13674 void *argp2 = 0 ;
13675 int res2 = 0 ;
13676 bool temp3 = false ;
13677 PyObject * obj0 = 0 ;
13678 PyObject * obj1 = 0 ;
13679 PyObject * obj2 = 0 ;
13680 char * kwnames[] = {
13681 (char *) "self",(char *) "fs",(char *) "location", NULL
13682 };
13683
13684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13686 if (!SWIG_IsOK(res1)) {
13687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13688 }
13689 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13691 if (!SWIG_IsOK(res2)) {
13692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13693 }
13694 if (!argp2) {
13695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13696 }
13697 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13698 {
13699 arg3 = wxString_in_helper(obj2);
13700 if (arg3 == NULL) SWIG_fail;
13701 temp3 = true;
13702 }
13703 {
13704 PyThreadState* __tstate = wxPyBeginAllowThreads();
13705 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13706 wxPyEndAllowThreads(__tstate);
13707 if (PyErr_Occurred()) SWIG_fail;
13708 }
13709 {
13710 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13711 }
13712 {
13713 if (temp3)
13714 delete arg3;
13715 }
13716 return resultobj;
13717 fail:
13718 {
13719 if (temp3)
13720 delete arg3;
13721 }
13722 return NULL;
13723 }
13724
13725
13726 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13727 PyObject *resultobj = 0;
13728 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13729 wxString *arg2 = 0 ;
13730 int arg3 = (int) 0 ;
13731 wxString result;
13732 void *argp1 = 0 ;
13733 int res1 = 0 ;
13734 bool temp2 = false ;
13735 int val3 ;
13736 int ecode3 = 0 ;
13737 PyObject * obj0 = 0 ;
13738 PyObject * obj1 = 0 ;
13739 PyObject * obj2 = 0 ;
13740 char * kwnames[] = {
13741 (char *) "self",(char *) "spec",(char *) "flags", NULL
13742 };
13743
13744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13746 if (!SWIG_IsOK(res1)) {
13747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13748 }
13749 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13750 {
13751 arg2 = wxString_in_helper(obj1);
13752 if (arg2 == NULL) SWIG_fail;
13753 temp2 = true;
13754 }
13755 if (obj2) {
13756 ecode3 = SWIG_AsVal_int(obj2, &val3);
13757 if (!SWIG_IsOK(ecode3)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13759 }
13760 arg3 = static_cast< int >(val3);
13761 }
13762 {
13763 PyThreadState* __tstate = wxPyBeginAllowThreads();
13764 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13765 wxPyEndAllowThreads(__tstate);
13766 if (PyErr_Occurred()) SWIG_fail;
13767 }
13768 {
13769 #if wxUSE_UNICODE
13770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13771 #else
13772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13773 #endif
13774 }
13775 {
13776 if (temp2)
13777 delete arg2;
13778 }
13779 return resultobj;
13780 fail:
13781 {
13782 if (temp2)
13783 delete arg2;
13784 }
13785 return NULL;
13786 }
13787
13788
13789 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13790 PyObject *resultobj = 0;
13791 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13792 wxString result;
13793 void *argp1 = 0 ;
13794 int res1 = 0 ;
13795 PyObject *swig_obj[1] ;
13796
13797 if (!args) SWIG_fail;
13798 swig_obj[0] = args;
13799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13800 if (!SWIG_IsOK(res1)) {
13801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13802 }
13803 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13804 {
13805 PyThreadState* __tstate = wxPyBeginAllowThreads();
13806 result = (arg1)->FindNext();
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 {
13811 #if wxUSE_UNICODE
13812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13813 #else
13814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13815 #endif
13816 }
13817 return resultobj;
13818 fail:
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13824 PyObject *obj;
13825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13826 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13827 return SWIG_Py_Void();
13828 }
13829
13830 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13831 return SWIG_Python_InitShadowInstance(args);
13832 }
13833
13834 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj = 0;
13836 wxString *arg1 = 0 ;
13837 wxImage *arg2 = 0 ;
13838 long arg3 ;
13839 bool temp1 = false ;
13840 void *argp2 = 0 ;
13841 int res2 = 0 ;
13842 long val3 ;
13843 int ecode3 = 0 ;
13844 PyObject * obj0 = 0 ;
13845 PyObject * obj1 = 0 ;
13846 PyObject * obj2 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "filename",(char *) "image",(char *) "type", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13852 {
13853 arg1 = wxString_in_helper(obj0);
13854 if (arg1 == NULL) SWIG_fail;
13855 temp1 = true;
13856 }
13857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13858 if (!SWIG_IsOK(res2)) {
13859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13860 }
13861 if (!argp2) {
13862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13863 }
13864 arg2 = reinterpret_cast< wxImage * >(argp2);
13865 ecode3 = SWIG_AsVal_long(obj2, &val3);
13866 if (!SWIG_IsOK(ecode3)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13868 }
13869 arg3 = static_cast< long >(val3);
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 resultobj = SWIG_Py_Void();
13877 {
13878 if (temp1)
13879 delete arg1;
13880 }
13881 return resultobj;
13882 fail:
13883 {
13884 if (temp1)
13885 delete arg1;
13886 }
13887 return NULL;
13888 }
13889
13890
13891 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj = 0;
13893 wxString *arg1 = 0 ;
13894 wxBitmap *arg2 = 0 ;
13895 long arg3 ;
13896 bool temp1 = false ;
13897 void *argp2 = 0 ;
13898 int res2 = 0 ;
13899 long val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 {
13910 arg1 = wxString_in_helper(obj0);
13911 if (arg1 == NULL) SWIG_fail;
13912 temp1 = true;
13913 }
13914 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13915 if (!SWIG_IsOK(res2)) {
13916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13917 }
13918 if (!argp2) {
13919 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13920 }
13921 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13922 ecode3 = SWIG_AsVal_long(obj2, &val3);
13923 if (!SWIG_IsOK(ecode3)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13925 }
13926 arg3 = static_cast< long >(val3);
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 resultobj = SWIG_Py_Void();
13934 {
13935 if (temp1)
13936 delete arg1;
13937 }
13938 return resultobj;
13939 fail:
13940 {
13941 if (temp1)
13942 delete arg1;
13943 }
13944 return NULL;
13945 }
13946
13947
13948 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj = 0;
13950 wxString *arg1 = 0 ;
13951 PyObject *arg2 = (PyObject *) 0 ;
13952 bool temp1 = false ;
13953 PyObject * obj0 = 0 ;
13954 PyObject * obj1 = 0 ;
13955 char * kwnames[] = {
13956 (char *) "filename",(char *) "data", NULL
13957 };
13958
13959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13960 {
13961 arg1 = wxString_in_helper(obj0);
13962 if (arg1 == NULL) SWIG_fail;
13963 temp1 = true;
13964 }
13965 arg2 = obj1;
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13969 wxPyEndAllowThreads(__tstate);
13970 if (PyErr_Occurred()) SWIG_fail;
13971 }
13972 resultobj = SWIG_Py_Void();
13973 {
13974 if (temp1)
13975 delete arg1;
13976 }
13977 return resultobj;
13978 fail:
13979 {
13980 if (temp1)
13981 delete arg1;
13982 }
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988 PyObject *resultobj = 0;
13989 wxMemoryFSHandler *result = 0 ;
13990
13991 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13992 {
13993 PyThreadState* __tstate = wxPyBeginAllowThreads();
13994 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13995 wxPyEndAllowThreads(__tstate);
13996 if (PyErr_Occurred()) SWIG_fail;
13997 }
13998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13999 return resultobj;
14000 fail:
14001 return NULL;
14002 }
14003
14004
14005 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj = 0;
14007 wxString *arg1 = 0 ;
14008 bool temp1 = false ;
14009 PyObject * obj0 = 0 ;
14010 char * kwnames[] = {
14011 (char *) "filename", NULL
14012 };
14013
14014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14015 {
14016 arg1 = wxString_in_helper(obj0);
14017 if (arg1 == NULL) SWIG_fail;
14018 temp1 = true;
14019 }
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_Py_Void();
14027 {
14028 if (temp1)
14029 delete arg1;
14030 }
14031 return resultobj;
14032 fail:
14033 {
14034 if (temp1)
14035 delete arg1;
14036 }
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14044 wxString *arg2 = 0 ;
14045 bool result;
14046 void *argp1 = 0 ;
14047 int res1 = 0 ;
14048 bool temp2 = false ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "location", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14059 }
14060 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14061 {
14062 arg2 = wxString_in_helper(obj1);
14063 if (arg2 == NULL) SWIG_fail;
14064 temp2 = true;
14065 }
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 {
14073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14074 }
14075 {
14076 if (temp2)
14077 delete arg2;
14078 }
14079 return resultobj;
14080 fail:
14081 {
14082 if (temp2)
14083 delete arg2;
14084 }
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14092 wxFileSystem *arg2 = 0 ;
14093 wxString *arg3 = 0 ;
14094 wxFSFile *result = 0 ;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 void *argp2 = 0 ;
14098 int res2 = 0 ;
14099 bool temp3 = false ;
14100 PyObject * obj0 = 0 ;
14101 PyObject * obj1 = 0 ;
14102 PyObject * obj2 = 0 ;
14103 char * kwnames[] = {
14104 (char *) "self",(char *) "fs",(char *) "location", NULL
14105 };
14106
14107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14111 }
14112 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14114 if (!SWIG_IsOK(res2)) {
14115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14116 }
14117 if (!argp2) {
14118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14119 }
14120 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14121 {
14122 arg3 = wxString_in_helper(obj2);
14123 if (arg3 == NULL) SWIG_fail;
14124 temp3 = true;
14125 }
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 {
14133 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14134 }
14135 {
14136 if (temp3)
14137 delete arg3;
14138 }
14139 return resultobj;
14140 fail:
14141 {
14142 if (temp3)
14143 delete arg3;
14144 }
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj = 0;
14151 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14152 wxString *arg2 = 0 ;
14153 int arg3 = (int) 0 ;
14154 wxString result;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 bool temp2 = false ;
14158 int val3 ;
14159 int ecode3 = 0 ;
14160 PyObject * obj0 = 0 ;
14161 PyObject * obj1 = 0 ;
14162 PyObject * obj2 = 0 ;
14163 char * kwnames[] = {
14164 (char *) "self",(char *) "spec",(char *) "flags", NULL
14165 };
14166
14167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14171 }
14172 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14173 {
14174 arg2 = wxString_in_helper(obj1);
14175 if (arg2 == NULL) SWIG_fail;
14176 temp2 = true;
14177 }
14178 if (obj2) {
14179 ecode3 = SWIG_AsVal_int(obj2, &val3);
14180 if (!SWIG_IsOK(ecode3)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14182 }
14183 arg3 = static_cast< int >(val3);
14184 }
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 {
14192 #if wxUSE_UNICODE
14193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14194 #else
14195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14196 #endif
14197 }
14198 {
14199 if (temp2)
14200 delete arg2;
14201 }
14202 return resultobj;
14203 fail:
14204 {
14205 if (temp2)
14206 delete arg2;
14207 }
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14213 PyObject *resultobj = 0;
14214 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14215 wxString result;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 PyObject *swig_obj[1] ;
14219
14220 if (!args) SWIG_fail;
14221 swig_obj[0] = args;
14222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14223 if (!SWIG_IsOK(res1)) {
14224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14225 }
14226 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 result = (arg1)->FindNext();
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234 #if wxUSE_UNICODE
14235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14236 #else
14237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14238 #endif
14239 }
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *obj;
14248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14249 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14250 return SWIG_Py_Void();
14251 }
14252
14253 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14254 return SWIG_Python_InitShadowInstance(args);
14255 }
14256
14257 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258 PyObject *resultobj = 0;
14259 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14260 wxString result;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 PyObject *swig_obj[1] ;
14264
14265 if (!args) SWIG_fail;
14266 swig_obj[0] = args;
14267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14270 }
14271 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (arg1)->GetName();
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 {
14279 #if wxUSE_UNICODE
14280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14281 #else
14282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14283 #endif
14284 }
14285 return resultobj;
14286 fail:
14287 return NULL;
14288 }
14289
14290
14291 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14292 PyObject *resultobj = 0;
14293 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14294 wxString result;
14295 void *argp1 = 0 ;
14296 int res1 = 0 ;
14297 PyObject *swig_obj[1] ;
14298
14299 if (!args) SWIG_fail;
14300 swig_obj[0] = args;
14301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14302 if (!SWIG_IsOK(res1)) {
14303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14304 }
14305 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (arg1)->GetExtension();
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 {
14313 #if wxUSE_UNICODE
14314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14315 #else
14316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14317 #endif
14318 }
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14326 PyObject *resultobj = 0;
14327 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14328 long result;
14329 void *argp1 = 0 ;
14330 int res1 = 0 ;
14331 PyObject *swig_obj[1] ;
14332
14333 if (!args) SWIG_fail;
14334 swig_obj[0] = args;
14335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14336 if (!SWIG_IsOK(res1)) {
14337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14338 }
14339 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (long)(arg1)->GetType();
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 resultobj = SWIG_From_long(static_cast< long >(result));
14347 return resultobj;
14348 fail:
14349 return NULL;
14350 }
14351
14352
14353 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14354 PyObject *resultobj = 0;
14355 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14356 wxString result;
14357 void *argp1 = 0 ;
14358 int res1 = 0 ;
14359 PyObject *swig_obj[1] ;
14360
14361 if (!args) SWIG_fail;
14362 swig_obj[0] = args;
14363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14364 if (!SWIG_IsOK(res1)) {
14365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14366 }
14367 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (arg1)->GetMimeType();
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 {
14375 #if wxUSE_UNICODE
14376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14377 #else
14378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14379 #endif
14380 }
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj = 0;
14389 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14390 wxString *arg2 = 0 ;
14391 bool result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 bool temp2 = false ;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "self",(char *) "name", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14403 if (!SWIG_IsOK(res1)) {
14404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14405 }
14406 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14407 {
14408 arg2 = wxString_in_helper(obj1);
14409 if (arg2 == NULL) SWIG_fail;
14410 temp2 = true;
14411 }
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 {
14419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14420 }
14421 {
14422 if (temp2)
14423 delete arg2;
14424 }
14425 return resultobj;
14426 fail:
14427 {
14428 if (temp2)
14429 delete arg2;
14430 }
14431 return NULL;
14432 }
14433
14434
14435 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj = 0;
14437 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14438 wxInputStream *arg2 = 0 ;
14439 bool result;
14440 void *argp1 = 0 ;
14441 int res1 = 0 ;
14442 wxPyInputStream *temp2 ;
14443 bool created2 ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 char * kwnames[] = {
14447 (char *) "self",(char *) "stream", NULL
14448 };
14449
14450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14452 if (!SWIG_IsOK(res1)) {
14453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14454 }
14455 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14456 {
14457 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14458 arg2 = temp2->m_wxis;
14459 created2 = false;
14460 } else {
14461 PyErr_Clear(); // clear the failure of the wxPyConvert above
14462 arg2 = wxPyCBInputStream_create(obj1, false);
14463 if (arg2 == NULL) {
14464 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14465 SWIG_fail;
14466 }
14467 created2 = true;
14468 }
14469 }
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 result = (bool)(arg1)->CanRead(*arg2);
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 {
14477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14478 }
14479 {
14480 if (created2) delete arg2;
14481 }
14482 return resultobj;
14483 fail:
14484 {
14485 if (created2) delete arg2;
14486 }
14487 return NULL;
14488 }
14489
14490
14491 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = 0;
14493 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14494 wxString *arg2 = 0 ;
14495 void *argp1 = 0 ;
14496 int res1 = 0 ;
14497 bool temp2 = false ;
14498 PyObject * obj0 = 0 ;
14499 PyObject * obj1 = 0 ;
14500 char * kwnames[] = {
14501 (char *) "self",(char *) "name", NULL
14502 };
14503
14504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14506 if (!SWIG_IsOK(res1)) {
14507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14508 }
14509 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14510 {
14511 arg2 = wxString_in_helper(obj1);
14512 if (arg2 == NULL) SWIG_fail;
14513 temp2 = true;
14514 }
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 (arg1)->SetName((wxString const &)*arg2);
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_Py_Void();
14522 {
14523 if (temp2)
14524 delete arg2;
14525 }
14526 return resultobj;
14527 fail:
14528 {
14529 if (temp2)
14530 delete arg2;
14531 }
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = 0;
14538 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14539 wxString *arg2 = 0 ;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 bool temp2 = false ;
14543 PyObject * obj0 = 0 ;
14544 PyObject * obj1 = 0 ;
14545 char * kwnames[] = {
14546 (char *) "self",(char *) "extension", NULL
14547 };
14548
14549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14553 }
14554 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14555 {
14556 arg2 = wxString_in_helper(obj1);
14557 if (arg2 == NULL) SWIG_fail;
14558 temp2 = true;
14559 }
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 (arg1)->SetExtension((wxString const &)*arg2);
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 resultobj = SWIG_Py_Void();
14567 {
14568 if (temp2)
14569 delete arg2;
14570 }
14571 return resultobj;
14572 fail:
14573 {
14574 if (temp2)
14575 delete arg2;
14576 }
14577 return NULL;
14578 }
14579
14580
14581 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj = 0;
14583 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14584 long arg2 ;
14585 void *argp1 = 0 ;
14586 int res1 = 0 ;
14587 long val2 ;
14588 int ecode2 = 0 ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 char * kwnames[] = {
14592 (char *) "self",(char *) "type", NULL
14593 };
14594
14595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14597 if (!SWIG_IsOK(res1)) {
14598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14599 }
14600 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14601 ecode2 = SWIG_AsVal_long(obj1, &val2);
14602 if (!SWIG_IsOK(ecode2)) {
14603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14604 }
14605 arg2 = static_cast< long >(val2);
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 (arg1)->SetType(arg2);
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 resultobj = SWIG_Py_Void();
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj = 0;
14621 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14622 wxString *arg2 = 0 ;
14623 void *argp1 = 0 ;
14624 int res1 = 0 ;
14625 bool temp2 = false ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 char * kwnames[] = {
14629 (char *) "self",(char *) "mimetype", NULL
14630 };
14631
14632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14636 }
14637 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 (arg1)->SetMimeType((wxString const &)*arg2);
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 resultobj = SWIG_Py_Void();
14650 {
14651 if (temp2)
14652 delete arg2;
14653 }
14654 return resultobj;
14655 fail:
14656 {
14657 if (temp2)
14658 delete arg2;
14659 }
14660 return NULL;
14661 }
14662
14663
14664 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14665 PyObject *obj;
14666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14667 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14668 return SWIG_Py_Void();
14669 }
14670
14671 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14672 PyObject *resultobj = 0;
14673 wxPyImageHandler *result = 0 ;
14674
14675 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (wxPyImageHandler *)new wxPyImageHandler();
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14683 return resultobj;
14684 fail:
14685 return NULL;
14686 }
14687
14688
14689 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14690 PyObject *resultobj = 0;
14691 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14692 PyObject *arg2 = (PyObject *) 0 ;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "self", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14705 }
14706 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14707 arg2 = obj1;
14708 {
14709 PyThreadState* __tstate = wxPyBeginAllowThreads();
14710 (arg1)->_SetSelf(arg2);
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 resultobj = SWIG_Py_Void();
14715 return resultobj;
14716 fail:
14717 return NULL;
14718 }
14719
14720
14721 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14722 PyObject *obj;
14723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14724 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14725 return SWIG_Py_Void();
14726 }
14727
14728 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14729 return SWIG_Python_InitShadowInstance(args);
14730 }
14731
14732 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxImageHistogram *result = 0 ;
14735
14736 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (wxImageHistogram *)new wxImageHistogram();
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14744 return resultobj;
14745 fail:
14746 return NULL;
14747 }
14748
14749
14750 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14751 PyObject *resultobj = 0;
14752 byte arg1 ;
14753 byte arg2 ;
14754 byte arg3 ;
14755 unsigned long result;
14756 unsigned char val1 ;
14757 int ecode1 = 0 ;
14758 unsigned char val2 ;
14759 int ecode2 = 0 ;
14760 unsigned char val3 ;
14761 int ecode3 = 0 ;
14762 PyObject * obj0 = 0 ;
14763 PyObject * obj1 = 0 ;
14764 PyObject * obj2 = 0 ;
14765 char * kwnames[] = {
14766 (char *) "r",(char *) "g",(char *) "b", NULL
14767 };
14768
14769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14770 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14771 if (!SWIG_IsOK(ecode1)) {
14772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14773 }
14774 arg1 = static_cast< byte >(val1);
14775 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14776 if (!SWIG_IsOK(ecode2)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14778 }
14779 arg2 = static_cast< byte >(val2);
14780 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14781 if (!SWIG_IsOK(ecode3)) {
14782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14783 }
14784 arg3 = static_cast< byte >(val3);
14785 {
14786 PyThreadState* __tstate = wxPyBeginAllowThreads();
14787 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14792 return resultobj;
14793 fail:
14794 return NULL;
14795 }
14796
14797
14798 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj = 0;
14800 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14801 byte *arg2 = (byte *) 0 ;
14802 byte *arg3 = (byte *) 0 ;
14803 byte *arg4 = (byte *) 0 ;
14804 byte arg5 = (byte) 1 ;
14805 byte arg6 = (byte) 0 ;
14806 byte arg7 = (byte) 0 ;
14807 bool result;
14808 void *argp1 = 0 ;
14809 int res1 = 0 ;
14810 byte temp2 ;
14811 int res2 = SWIG_TMPOBJ ;
14812 byte temp3 ;
14813 int res3 = SWIG_TMPOBJ ;
14814 byte temp4 ;
14815 int res4 = SWIG_TMPOBJ ;
14816 unsigned char val5 ;
14817 int ecode5 = 0 ;
14818 unsigned char val6 ;
14819 int ecode6 = 0 ;
14820 unsigned char val7 ;
14821 int ecode7 = 0 ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 PyObject * obj3 = 0 ;
14826 char * kwnames[] = {
14827 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14828 };
14829
14830 arg2 = &temp2;
14831 arg3 = &temp3;
14832 arg4 = &temp4;
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14837 }
14838 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14839 if (obj1) {
14840 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14841 if (!SWIG_IsOK(ecode5)) {
14842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14843 }
14844 arg5 = static_cast< byte >(val5);
14845 }
14846 if (obj2) {
14847 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14848 if (!SWIG_IsOK(ecode6)) {
14849 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14850 }
14851 arg6 = static_cast< byte >(val6);
14852 }
14853 if (obj3) {
14854 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14855 if (!SWIG_IsOK(ecode7)) {
14856 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14857 }
14858 arg7 = static_cast< byte >(val7);
14859 }
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 {
14867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14868 }
14869 if (SWIG_IsTmpObj(res2)) {
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14871 } else {
14872 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14874 }
14875 if (SWIG_IsTmpObj(res3)) {
14876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14877 } else {
14878 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14880 }
14881 if (SWIG_IsTmpObj(res4)) {
14882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14883 } else {
14884 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14886 }
14887 return resultobj;
14888 fail:
14889 return NULL;
14890 }
14891
14892
14893 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14894 PyObject *resultobj = 0;
14895 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14896 unsigned long arg2 ;
14897 unsigned long result;
14898 void *argp1 = 0 ;
14899 int res1 = 0 ;
14900 unsigned long val2 ;
14901 int ecode2 = 0 ;
14902 PyObject * obj0 = 0 ;
14903 PyObject * obj1 = 0 ;
14904 char * kwnames[] = {
14905 (char *) "self",(char *) "key", NULL
14906 };
14907
14908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14914 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14915 if (!SWIG_IsOK(ecode2)) {
14916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14917 }
14918 arg2 = static_cast< unsigned long >(val2);
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj = 0;
14934 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14935 byte arg2 ;
14936 byte arg3 ;
14937 byte arg4 ;
14938 unsigned long result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 unsigned char val2 ;
14942 int ecode2 = 0 ;
14943 unsigned char val3 ;
14944 int ecode3 = 0 ;
14945 unsigned char val4 ;
14946 int ecode4 = 0 ;
14947 PyObject * obj0 = 0 ;
14948 PyObject * obj1 = 0 ;
14949 PyObject * obj2 = 0 ;
14950 PyObject * obj3 = 0 ;
14951 char * kwnames[] = {
14952 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14953 };
14954
14955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14959 }
14960 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14961 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14962 if (!SWIG_IsOK(ecode2)) {
14963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14964 }
14965 arg2 = static_cast< byte >(val2);
14966 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14967 if (!SWIG_IsOK(ecode3)) {
14968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14969 }
14970 arg3 = static_cast< byte >(val3);
14971 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14972 if (!SWIG_IsOK(ecode4)) {
14973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14974 }
14975 arg4 = static_cast< byte >(val4);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj = 0;
14991 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14992 wxColour *arg2 = 0 ;
14993 unsigned long result;
14994 void *argp1 = 0 ;
14995 int res1 = 0 ;
14996 wxColour temp2 ;
14997 PyObject * obj0 = 0 ;
14998 PyObject * obj1 = 0 ;
14999 char * kwnames[] = {
15000 (char *) "self",(char *) "colour", NULL
15001 };
15002
15003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15005 if (!SWIG_IsOK(res1)) {
15006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15007 }
15008 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15009 {
15010 arg2 = &temp2;
15011 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15012 }
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15016 wxPyEndAllowThreads(__tstate);
15017 if (PyErr_Occurred()) SWIG_fail;
15018 }
15019 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15020 return resultobj;
15021 fail:
15022 return NULL;
15023 }
15024
15025
15026 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15027 PyObject *obj;
15028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15029 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15030 return SWIG_Py_Void();
15031 }
15032
15033 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15034 return SWIG_Python_InitShadowInstance(args);
15035 }
15036
15037 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15038 PyObject *resultobj = 0;
15039 byte arg1 = (byte) 0 ;
15040 byte arg2 = (byte) 0 ;
15041 byte arg3 = (byte) 0 ;
15042 wxImage_RGBValue *result = 0 ;
15043 unsigned char val1 ;
15044 int ecode1 = 0 ;
15045 unsigned char val2 ;
15046 int ecode2 = 0 ;
15047 unsigned char val3 ;
15048 int ecode3 = 0 ;
15049 PyObject * obj0 = 0 ;
15050 PyObject * obj1 = 0 ;
15051 PyObject * obj2 = 0 ;
15052 char * kwnames[] = {
15053 (char *) "r",(char *) "g",(char *) "b", NULL
15054 };
15055
15056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15057 if (obj0) {
15058 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15059 if (!SWIG_IsOK(ecode1)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15061 }
15062 arg1 = static_cast< byte >(val1);
15063 }
15064 if (obj1) {
15065 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15066 if (!SWIG_IsOK(ecode2)) {
15067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15068 }
15069 arg2 = static_cast< byte >(val2);
15070 }
15071 if (obj2) {
15072 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15073 if (!SWIG_IsOK(ecode3)) {
15074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15075 }
15076 arg3 = static_cast< byte >(val3);
15077 }
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15085 return resultobj;
15086 fail:
15087 return NULL;
15088 }
15089
15090
15091 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15092 PyObject *resultobj = 0;
15093 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15094 byte arg2 ;
15095 void *argp1 = 0 ;
15096 int res1 = 0 ;
15097 unsigned char val2 ;
15098 int ecode2 = 0 ;
15099 PyObject *swig_obj[2] ;
15100
15101 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15105 }
15106 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15107 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15108 if (!SWIG_IsOK(ecode2)) {
15109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15110 }
15111 arg2 = static_cast< byte >(val2);
15112 if (arg1) (arg1)->red = arg2;
15113
15114 resultobj = SWIG_Py_Void();
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15122 PyObject *resultobj = 0;
15123 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15124 byte result;
15125 void *argp1 = 0 ;
15126 int res1 = 0 ;
15127 PyObject *swig_obj[1] ;
15128
15129 if (!args) SWIG_fail;
15130 swig_obj[0] = args;
15131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15132 if (!SWIG_IsOK(res1)) {
15133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15134 }
15135 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15136 result = (byte) ((arg1)->red);
15137 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15145 PyObject *resultobj = 0;
15146 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15147 byte arg2 ;
15148 void *argp1 = 0 ;
15149 int res1 = 0 ;
15150 unsigned char val2 ;
15151 int ecode2 = 0 ;
15152 PyObject *swig_obj[2] ;
15153
15154 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15158 }
15159 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15160 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15161 if (!SWIG_IsOK(ecode2)) {
15162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15163 }
15164 arg2 = static_cast< byte >(val2);
15165 if (arg1) (arg1)->green = arg2;
15166
15167 resultobj = SWIG_Py_Void();
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15175 PyObject *resultobj = 0;
15176 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15177 byte result;
15178 void *argp1 = 0 ;
15179 int res1 = 0 ;
15180 PyObject *swig_obj[1] ;
15181
15182 if (!args) SWIG_fail;
15183 swig_obj[0] = args;
15184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15185 if (!SWIG_IsOK(res1)) {
15186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15187 }
15188 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15189 result = (byte) ((arg1)->green);
15190 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15191 return resultobj;
15192 fail:
15193 return NULL;
15194 }
15195
15196
15197 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15198 PyObject *resultobj = 0;
15199 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15200 byte arg2 ;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 unsigned char val2 ;
15204 int ecode2 = 0 ;
15205 PyObject *swig_obj[2] ;
15206
15207 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15209 if (!SWIG_IsOK(res1)) {
15210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15211 }
15212 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15213 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15214 if (!SWIG_IsOK(ecode2)) {
15215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15216 }
15217 arg2 = static_cast< byte >(val2);
15218 if (arg1) (arg1)->blue = arg2;
15219
15220 resultobj = SWIG_Py_Void();
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15228 PyObject *resultobj = 0;
15229 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15230 byte result;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 PyObject *swig_obj[1] ;
15234
15235 if (!args) SWIG_fail;
15236 swig_obj[0] = args;
15237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15238 if (!SWIG_IsOK(res1)) {
15239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15240 }
15241 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15242 result = (byte) ((arg1)->blue);
15243 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15244 return resultobj;
15245 fail:
15246 return NULL;
15247 }
15248
15249
15250 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15251 PyObject *obj;
15252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15253 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15254 return SWIG_Py_Void();
15255 }
15256
15257 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 return SWIG_Python_InitShadowInstance(args);
15259 }
15260
15261 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15262 PyObject *resultobj = 0;
15263 double arg1 = (double) 0.0 ;
15264 double arg2 = (double) 0.0 ;
15265 double arg3 = (double) 0.0 ;
15266 wxImage_HSVValue *result = 0 ;
15267 double val1 ;
15268 int ecode1 = 0 ;
15269 double val2 ;
15270 int ecode2 = 0 ;
15271 double val3 ;
15272 int ecode3 = 0 ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 PyObject * obj2 = 0 ;
15276 char * kwnames[] = {
15277 (char *) "h",(char *) "s",(char *) "v", NULL
15278 };
15279
15280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15281 if (obj0) {
15282 ecode1 = SWIG_AsVal_double(obj0, &val1);
15283 if (!SWIG_IsOK(ecode1)) {
15284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15285 }
15286 arg1 = static_cast< double >(val1);
15287 }
15288 if (obj1) {
15289 ecode2 = SWIG_AsVal_double(obj1, &val2);
15290 if (!SWIG_IsOK(ecode2)) {
15291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15292 }
15293 arg2 = static_cast< double >(val2);
15294 }
15295 if (obj2) {
15296 ecode3 = SWIG_AsVal_double(obj2, &val3);
15297 if (!SWIG_IsOK(ecode3)) {
15298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15299 }
15300 arg3 = static_cast< double >(val3);
15301 }
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15316 PyObject *resultobj = 0;
15317 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15318 double arg2 ;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 double val2 ;
15322 int ecode2 = 0 ;
15323 PyObject *swig_obj[2] ;
15324
15325 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15329 }
15330 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15331 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15332 if (!SWIG_IsOK(ecode2)) {
15333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15334 }
15335 arg2 = static_cast< double >(val2);
15336 if (arg1) (arg1)->hue = arg2;
15337
15338 resultobj = SWIG_Py_Void();
15339 return resultobj;
15340 fail:
15341 return NULL;
15342 }
15343
15344
15345 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15346 PyObject *resultobj = 0;
15347 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15348 double result;
15349 void *argp1 = 0 ;
15350 int res1 = 0 ;
15351 PyObject *swig_obj[1] ;
15352
15353 if (!args) SWIG_fail;
15354 swig_obj[0] = args;
15355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15356 if (!SWIG_IsOK(res1)) {
15357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15358 }
15359 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15360 result = (double) ((arg1)->hue);
15361 resultobj = SWIG_From_double(static_cast< double >(result));
15362 return resultobj;
15363 fail:
15364 return NULL;
15365 }
15366
15367
15368 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15369 PyObject *resultobj = 0;
15370 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15371 double arg2 ;
15372 void *argp1 = 0 ;
15373 int res1 = 0 ;
15374 double val2 ;
15375 int ecode2 = 0 ;
15376 PyObject *swig_obj[2] ;
15377
15378 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15380 if (!SWIG_IsOK(res1)) {
15381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15382 }
15383 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15384 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15385 if (!SWIG_IsOK(ecode2)) {
15386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15387 }
15388 arg2 = static_cast< double >(val2);
15389 if (arg1) (arg1)->saturation = arg2;
15390
15391 resultobj = SWIG_Py_Void();
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15399 PyObject *resultobj = 0;
15400 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15401 double result;
15402 void *argp1 = 0 ;
15403 int res1 = 0 ;
15404 PyObject *swig_obj[1] ;
15405
15406 if (!args) SWIG_fail;
15407 swig_obj[0] = args;
15408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15413 result = (double) ((arg1)->saturation);
15414 resultobj = SWIG_From_double(static_cast< double >(result));
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15424 double arg2 ;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 double val2 ;
15428 int ecode2 = 0 ;
15429 PyObject *swig_obj[2] ;
15430
15431 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15435 }
15436 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15437 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15438 if (!SWIG_IsOK(ecode2)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15440 }
15441 arg2 = static_cast< double >(val2);
15442 if (arg1) (arg1)->value = arg2;
15443
15444 resultobj = SWIG_Py_Void();
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15452 PyObject *resultobj = 0;
15453 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15454 double result;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 PyObject *swig_obj[1] ;
15458
15459 if (!args) SWIG_fail;
15460 swig_obj[0] = args;
15461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15464 }
15465 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15466 result = (double) ((arg1)->value);
15467 resultobj = SWIG_From_double(static_cast< double >(result));
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15475 PyObject *obj;
15476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15477 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15478 return SWIG_Py_Void();
15479 }
15480
15481 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15482 return SWIG_Python_InitShadowInstance(args);
15483 }
15484
15485 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj = 0;
15487 wxString *arg1 = 0 ;
15488 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15489 int arg3 = (int) -1 ;
15490 wxImage *result = 0 ;
15491 bool temp1 = false ;
15492 long val2 ;
15493 int ecode2 = 0 ;
15494 int val3 ;
15495 int ecode3 = 0 ;
15496 PyObject * obj0 = 0 ;
15497 PyObject * obj1 = 0 ;
15498 PyObject * obj2 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "name",(char *) "type",(char *) "index", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15504 {
15505 arg1 = wxString_in_helper(obj0);
15506 if (arg1 == NULL) SWIG_fail;
15507 temp1 = true;
15508 }
15509 if (obj1) {
15510 ecode2 = SWIG_AsVal_long(obj1, &val2);
15511 if (!SWIG_IsOK(ecode2)) {
15512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15513 }
15514 arg2 = static_cast< long >(val2);
15515 }
15516 if (obj2) {
15517 ecode3 = SWIG_AsVal_int(obj2, &val3);
15518 if (!SWIG_IsOK(ecode3)) {
15519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15520 }
15521 arg3 = static_cast< int >(val3);
15522 }
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15530 {
15531 if (temp1)
15532 delete arg1;
15533 }
15534 return resultobj;
15535 fail:
15536 {
15537 if (temp1)
15538 delete arg1;
15539 }
15540 return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15545 PyObject *resultobj = 0;
15546 wxImage *arg1 = (wxImage *) 0 ;
15547 void *argp1 = 0 ;
15548 int res1 = 0 ;
15549 PyObject *swig_obj[1] ;
15550
15551 if (!args) SWIG_fail;
15552 swig_obj[0] = args;
15553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15554 if (!SWIG_IsOK(res1)) {
15555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15556 }
15557 arg1 = reinterpret_cast< wxImage * >(argp1);
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 delete arg1;
15561
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj = 0;
15574 wxString *arg1 = 0 ;
15575 wxString *arg2 = 0 ;
15576 int arg3 = (int) -1 ;
15577 wxImage *result = 0 ;
15578 bool temp1 = false ;
15579 bool temp2 = false ;
15580 int val3 ;
15581 int ecode3 = 0 ;
15582 PyObject * obj0 = 0 ;
15583 PyObject * obj1 = 0 ;
15584 PyObject * obj2 = 0 ;
15585 char * kwnames[] = {
15586 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15587 };
15588
15589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15590 {
15591 arg1 = wxString_in_helper(obj0);
15592 if (arg1 == NULL) SWIG_fail;
15593 temp1 = true;
15594 }
15595 {
15596 arg2 = wxString_in_helper(obj1);
15597 if (arg2 == NULL) SWIG_fail;
15598 temp2 = true;
15599 }
15600 if (obj2) {
15601 ecode3 = SWIG_AsVal_int(obj2, &val3);
15602 if (!SWIG_IsOK(ecode3)) {
15603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15604 }
15605 arg3 = static_cast< int >(val3);
15606 }
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15614 {
15615 if (temp1)
15616 delete arg1;
15617 }
15618 {
15619 if (temp2)
15620 delete arg2;
15621 }
15622 return resultobj;
15623 fail:
15624 {
15625 if (temp1)
15626 delete arg1;
15627 }
15628 {
15629 if (temp2)
15630 delete arg2;
15631 }
15632 return NULL;
15633 }
15634
15635
15636 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj = 0;
15638 wxInputStream *arg1 = 0 ;
15639 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15640 int arg3 = (int) -1 ;
15641 wxImage *result = 0 ;
15642 wxPyInputStream *temp1 ;
15643 bool created1 ;
15644 long val2 ;
15645 int ecode2 = 0 ;
15646 int val3 ;
15647 int ecode3 = 0 ;
15648 PyObject * obj0 = 0 ;
15649 PyObject * obj1 = 0 ;
15650 PyObject * obj2 = 0 ;
15651 char * kwnames[] = {
15652 (char *) "stream",(char *) "type",(char *) "index", NULL
15653 };
15654
15655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15656 {
15657 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15658 arg1 = temp1->m_wxis;
15659 created1 = false;
15660 } else {
15661 PyErr_Clear(); // clear the failure of the wxPyConvert above
15662 arg1 = wxPyCBInputStream_create(obj0, false);
15663 if (arg1 == NULL) {
15664 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15665 SWIG_fail;
15666 }
15667 created1 = true;
15668 }
15669 }
15670 if (obj1) {
15671 ecode2 = SWIG_AsVal_long(obj1, &val2);
15672 if (!SWIG_IsOK(ecode2)) {
15673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15674 }
15675 arg2 = static_cast< long >(val2);
15676 }
15677 if (obj2) {
15678 ecode3 = SWIG_AsVal_int(obj2, &val3);
15679 if (!SWIG_IsOK(ecode3)) {
15680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15681 }
15682 arg3 = static_cast< int >(val3);
15683 }
15684 {
15685 PyThreadState* __tstate = wxPyBeginAllowThreads();
15686 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15687 wxPyEndAllowThreads(__tstate);
15688 if (PyErr_Occurred()) SWIG_fail;
15689 }
15690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15691 {
15692 if (created1) delete arg1;
15693 }
15694 return resultobj;
15695 fail:
15696 {
15697 if (created1) delete arg1;
15698 }
15699 return NULL;
15700 }
15701
15702
15703 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj = 0;
15705 wxInputStream *arg1 = 0 ;
15706 wxString *arg2 = 0 ;
15707 int arg3 = (int) -1 ;
15708 wxImage *result = 0 ;
15709 wxPyInputStream *temp1 ;
15710 bool created1 ;
15711 bool temp2 = false ;
15712 int val3 ;
15713 int ecode3 = 0 ;
15714 PyObject * obj0 = 0 ;
15715 PyObject * obj1 = 0 ;
15716 PyObject * obj2 = 0 ;
15717 char * kwnames[] = {
15718 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15719 };
15720
15721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15722 {
15723 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15724 arg1 = temp1->m_wxis;
15725 created1 = false;
15726 } else {
15727 PyErr_Clear(); // clear the failure of the wxPyConvert above
15728 arg1 = wxPyCBInputStream_create(obj0, false);
15729 if (arg1 == NULL) {
15730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15731 SWIG_fail;
15732 }
15733 created1 = true;
15734 }
15735 }
15736 {
15737 arg2 = wxString_in_helper(obj1);
15738 if (arg2 == NULL) SWIG_fail;
15739 temp2 = true;
15740 }
15741 if (obj2) {
15742 ecode3 = SWIG_AsVal_int(obj2, &val3);
15743 if (!SWIG_IsOK(ecode3)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15745 }
15746 arg3 = static_cast< int >(val3);
15747 }
15748 {
15749 PyThreadState* __tstate = wxPyBeginAllowThreads();
15750 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15751 wxPyEndAllowThreads(__tstate);
15752 if (PyErr_Occurred()) SWIG_fail;
15753 }
15754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15755 {
15756 if (created1) delete arg1;
15757 }
15758 {
15759 if (temp2)
15760 delete arg2;
15761 }
15762 return resultobj;
15763 fail:
15764 {
15765 if (created1) delete arg1;
15766 }
15767 {
15768 if (temp2)
15769 delete arg2;
15770 }
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = 0;
15777 int arg1 = (int) 0 ;
15778 int arg2 = (int) 0 ;
15779 bool arg3 = (bool) true ;
15780 wxImage *result = 0 ;
15781 int val1 ;
15782 int ecode1 = 0 ;
15783 int val2 ;
15784 int ecode2 = 0 ;
15785 bool val3 ;
15786 int ecode3 = 0 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 PyObject * obj2 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "width",(char *) "height",(char *) "clear", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15795 if (obj0) {
15796 ecode1 = SWIG_AsVal_int(obj0, &val1);
15797 if (!SWIG_IsOK(ecode1)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15799 }
15800 arg1 = static_cast< int >(val1);
15801 }
15802 if (obj1) {
15803 ecode2 = SWIG_AsVal_int(obj1, &val2);
15804 if (!SWIG_IsOK(ecode2)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15806 }
15807 arg2 = static_cast< int >(val2);
15808 }
15809 if (obj2) {
15810 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15811 if (!SWIG_IsOK(ecode3)) {
15812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15813 }
15814 arg3 = static_cast< bool >(val3);
15815 }
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15830 PyObject *resultobj = 0;
15831 wxBitmap *arg1 = 0 ;
15832 wxImage *result = 0 ;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject * obj0 = 0 ;
15836 char * kwnames[] = {
15837 (char *) "bitmap", NULL
15838 };
15839
15840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15841 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15842 if (!SWIG_IsOK(res1)) {
15843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15844 }
15845 if (!argp1) {
15846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15847 }
15848 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15849 {
15850 if (!wxPyCheckForApp()) SWIG_fail;
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 int arg1 ;
15866 int arg2 ;
15867 buffer arg3 ;
15868 int arg4 ;
15869 wxImage *result = 0 ;
15870 int val1 ;
15871 int ecode1 = 0 ;
15872 int val2 ;
15873 int ecode2 = 0 ;
15874 Py_ssize_t temp3 ;
15875 PyObject * obj0 = 0 ;
15876 PyObject * obj1 = 0 ;
15877 PyObject * obj2 = 0 ;
15878 char * kwnames[] = {
15879 (char *) "width",(char *) "height",(char *) "data", NULL
15880 };
15881
15882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15883 ecode1 = SWIG_AsVal_int(obj0, &val1);
15884 if (!SWIG_IsOK(ecode1)) {
15885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15886 }
15887 arg1 = static_cast< int >(val1);
15888 ecode2 = SWIG_AsVal_int(obj1, &val2);
15889 if (!SWIG_IsOK(ecode2)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15891 }
15892 arg2 = static_cast< int >(val2);
15893 {
15894 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15895 arg4 = (int)temp3;
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj = 0;
15912 int arg1 ;
15913 int arg2 ;
15914 buffer arg3 ;
15915 int arg4 ;
15916 buffer arg5 ;
15917 int arg6 ;
15918 wxImage *result = 0 ;
15919 int val1 ;
15920 int ecode1 = 0 ;
15921 int val2 ;
15922 int ecode2 = 0 ;
15923 Py_ssize_t temp3 ;
15924 Py_ssize_t temp5 ;
15925 PyObject * obj0 = 0 ;
15926 PyObject * obj1 = 0 ;
15927 PyObject * obj2 = 0 ;
15928 PyObject * obj3 = 0 ;
15929 char * kwnames[] = {
15930 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15931 };
15932
15933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15934 ecode1 = SWIG_AsVal_int(obj0, &val1);
15935 if (!SWIG_IsOK(ecode1)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15937 }
15938 arg1 = static_cast< int >(val1);
15939 ecode2 = SWIG_AsVal_int(obj1, &val2);
15940 if (!SWIG_IsOK(ecode2)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15942 }
15943 arg2 = static_cast< int >(val2);
15944 {
15945 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15946 arg4 = (int)temp3;
15947 }
15948 {
15949 if (obj3 != Py_None) {
15950 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15951 arg6 = (int)temp5;
15952 }
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj = 0;
15969 wxImage *arg1 = (wxImage *) 0 ;
15970 int arg2 ;
15971 int arg3 ;
15972 bool arg4 = (bool) true ;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 int val2 ;
15976 int ecode2 = 0 ;
15977 int val3 ;
15978 int ecode3 = 0 ;
15979 bool val4 ;
15980 int ecode4 = 0 ;
15981 PyObject * obj0 = 0 ;
15982 PyObject * obj1 = 0 ;
15983 PyObject * obj2 = 0 ;
15984 PyObject * obj3 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15991 if (!SWIG_IsOK(res1)) {
15992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15993 }
15994 arg1 = reinterpret_cast< wxImage * >(argp1);
15995 ecode2 = SWIG_AsVal_int(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15998 }
15999 arg2 = static_cast< int >(val2);
16000 ecode3 = SWIG_AsVal_int(obj2, &val3);
16001 if (!SWIG_IsOK(ecode3)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16003 }
16004 arg3 = static_cast< int >(val3);
16005 if (obj3) {
16006 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16007 if (!SWIG_IsOK(ecode4)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16009 }
16010 arg4 = static_cast< bool >(val4);
16011 }
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 (arg1)->Create(arg2,arg3,arg4);
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 resultobj = SWIG_Py_Void();
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxImage *arg1 = (wxImage *) 0 ;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 PyObject *swig_obj[1] ;
16031
16032 if (!args) SWIG_fail;
16033 swig_obj[0] = args;
16034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16035 if (!SWIG_IsOK(res1)) {
16036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16037 }
16038 arg1 = reinterpret_cast< wxImage * >(argp1);
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 (arg1)->Destroy();
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_Py_Void();
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj = 0;
16054 wxImage *arg1 = (wxImage *) 0 ;
16055 int arg2 ;
16056 int arg3 ;
16057 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16058 SwigValueWrapper<wxImage > result;
16059 void *argp1 = 0 ;
16060 int res1 = 0 ;
16061 int val2 ;
16062 int ecode2 = 0 ;
16063 int val3 ;
16064 int ecode3 = 0 ;
16065 int val4 ;
16066 int ecode4 = 0 ;
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 PyObject * obj2 = 0 ;
16070 PyObject * obj3 = 0 ;
16071 char * kwnames[] = {
16072 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16073 };
16074
16075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16077 if (!SWIG_IsOK(res1)) {
16078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16079 }
16080 arg1 = reinterpret_cast< wxImage * >(argp1);
16081 ecode2 = SWIG_AsVal_int(obj1, &val2);
16082 if (!SWIG_IsOK(ecode2)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16084 }
16085 arg2 = static_cast< int >(val2);
16086 ecode3 = SWIG_AsVal_int(obj2, &val3);
16087 if (!SWIG_IsOK(ecode3)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16089 }
16090 arg3 = static_cast< int >(val3);
16091 if (obj3) {
16092 ecode4 = SWIG_AsVal_int(obj3, &val4);
16093 if (!SWIG_IsOK(ecode4)) {
16094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16095 }
16096 arg4 = static_cast< int >(val4);
16097 }
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (arg1)->Scale(arg2,arg3,arg4);
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj = 0;
16113 wxImage *arg1 = (wxImage *) 0 ;
16114 int arg2 ;
16115 int arg3 ;
16116 SwigValueWrapper<wxImage > result;
16117 void *argp1 = 0 ;
16118 int res1 = 0 ;
16119 int val2 ;
16120 int ecode2 = 0 ;
16121 int val3 ;
16122 int ecode3 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 char * kwnames[] = {
16127 (char *) "self",(char *) "width",(char *) "height", NULL
16128 };
16129
16130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16134 }
16135 arg1 = reinterpret_cast< wxImage * >(argp1);
16136 ecode2 = SWIG_AsVal_int(obj1, &val2);
16137 if (!SWIG_IsOK(ecode2)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16139 }
16140 arg2 = static_cast< int >(val2);
16141 ecode3 = SWIG_AsVal_int(obj2, &val3);
16142 if (!SWIG_IsOK(ecode3)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16144 }
16145 arg3 = static_cast< int >(val3);
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16153 return resultobj;
16154 fail:
16155 return NULL;
16156 }
16157
16158
16159 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj = 0;
16161 wxImage *arg1 = (wxImage *) 0 ;
16162 int arg2 ;
16163 int arg3 ;
16164 SwigValueWrapper<wxImage > result;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 int val2 ;
16168 int ecode2 = 0 ;
16169 int val3 ;
16170 int ecode3 = 0 ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 PyObject * obj2 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "width",(char *) "height", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 ecode2 = SWIG_AsVal_int(obj1, &val2);
16185 if (!SWIG_IsOK(ecode2)) {
16186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16187 }
16188 arg2 = static_cast< int >(val2);
16189 ecode3 = SWIG_AsVal_int(obj2, &val3);
16190 if (!SWIG_IsOK(ecode3)) {
16191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16192 }
16193 arg3 = static_cast< int >(val3);
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj = 0;
16209 wxImage *arg1 = (wxImage *) 0 ;
16210 int arg2 ;
16211 SwigValueWrapper<wxImage > result;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 int val2 ;
16215 int ecode2 = 0 ;
16216 PyObject * obj0 = 0 ;
16217 PyObject * obj1 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "radius", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 ecode2 = SWIG_AsVal_int(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16231 }
16232 arg2 = static_cast< int >(val2);
16233 {
16234 PyThreadState* __tstate = wxPyBeginAllowThreads();
16235 result = (arg1)->Blur(arg2);
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16247 PyObject *resultobj = 0;
16248 wxImage *arg1 = (wxImage *) 0 ;
16249 int arg2 ;
16250 SwigValueWrapper<wxImage > result;
16251 void *argp1 = 0 ;
16252 int res1 = 0 ;
16253 int val2 ;
16254 int ecode2 = 0 ;
16255 PyObject * obj0 = 0 ;
16256 PyObject * obj1 = 0 ;
16257 char * kwnames[] = {
16258 (char *) "self",(char *) "radius", NULL
16259 };
16260
16261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16263 if (!SWIG_IsOK(res1)) {
16264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16265 }
16266 arg1 = reinterpret_cast< wxImage * >(argp1);
16267 ecode2 = SWIG_AsVal_int(obj1, &val2);
16268 if (!SWIG_IsOK(ecode2)) {
16269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16270 }
16271 arg2 = static_cast< int >(val2);
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = (arg1)->BlurHorizontal(arg2);
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj = 0;
16287 wxImage *arg1 = (wxImage *) 0 ;
16288 int arg2 ;
16289 SwigValueWrapper<wxImage > result;
16290 void *argp1 = 0 ;
16291 int res1 = 0 ;
16292 int val2 ;
16293 int ecode2 = 0 ;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 char * kwnames[] = {
16297 (char *) "self",(char *) "radius", NULL
16298 };
16299
16300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16302 if (!SWIG_IsOK(res1)) {
16303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16304 }
16305 arg1 = reinterpret_cast< wxImage * >(argp1);
16306 ecode2 = SWIG_AsVal_int(obj1, &val2);
16307 if (!SWIG_IsOK(ecode2)) {
16308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16309 }
16310 arg2 = static_cast< int >(val2);
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 result = (arg1)->BlurVertical(arg2);
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16318 return resultobj;
16319 fail:
16320 return NULL;
16321 }
16322
16323
16324 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16325 PyObject *resultobj = 0;
16326 wxImage *arg1 = (wxImage *) 0 ;
16327 int arg2 ;
16328 int arg3 ;
16329 SwigValueWrapper<wxImage > result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 int val2 ;
16333 int ecode2 = 0 ;
16334 int val3 ;
16335 int ecode3 = 0 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 PyObject * obj2 = 0 ;
16339 char * kwnames[] = {
16340 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16341 };
16342
16343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16345 if (!SWIG_IsOK(res1)) {
16346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16347 }
16348 arg1 = reinterpret_cast< wxImage * >(argp1);
16349 ecode2 = SWIG_AsVal_int(obj1, &val2);
16350 if (!SWIG_IsOK(ecode2)) {
16351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16352 }
16353 arg2 = static_cast< int >(val2);
16354 ecode3 = SWIG_AsVal_int(obj2, &val3);
16355 if (!SWIG_IsOK(ecode3)) {
16356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16357 }
16358 arg3 = static_cast< int >(val3);
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj = 0;
16374 wxImage *arg1 = (wxImage *) 0 ;
16375 int arg2 ;
16376 int arg3 ;
16377 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16378 wxImage *result = 0 ;
16379 void *argp1 = 0 ;
16380 int res1 = 0 ;
16381 int val2 ;
16382 int ecode2 = 0 ;
16383 int val3 ;
16384 int ecode3 = 0 ;
16385 int val4 ;
16386 int ecode4 = 0 ;
16387 PyObject * obj0 = 0 ;
16388 PyObject * obj1 = 0 ;
16389 PyObject * obj2 = 0 ;
16390 PyObject * obj3 = 0 ;
16391 char * kwnames[] = {
16392 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16393 };
16394
16395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16397 if (!SWIG_IsOK(res1)) {
16398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16399 }
16400 arg1 = reinterpret_cast< wxImage * >(argp1);
16401 ecode2 = SWIG_AsVal_int(obj1, &val2);
16402 if (!SWIG_IsOK(ecode2)) {
16403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16404 }
16405 arg2 = static_cast< int >(val2);
16406 ecode3 = SWIG_AsVal_int(obj2, &val3);
16407 if (!SWIG_IsOK(ecode3)) {
16408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16409 }
16410 arg3 = static_cast< int >(val3);
16411 if (obj3) {
16412 ecode4 = SWIG_AsVal_int(obj3, &val4);
16413 if (!SWIG_IsOK(ecode4)) {
16414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16415 }
16416 arg4 = static_cast< int >(val4);
16417 }
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 {
16421 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16422 result = (wxImage *) &_result_ref;
16423 }
16424 wxPyEndAllowThreads(__tstate);
16425 if (PyErr_Occurred()) SWIG_fail;
16426 }
16427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16428 return resultobj;
16429 fail:
16430 return NULL;
16431 }
16432
16433
16434 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj = 0;
16436 wxImage *arg1 = (wxImage *) 0 ;
16437 wxSize *arg2 = 0 ;
16438 wxPoint *arg3 = 0 ;
16439 int arg4 = (int) -1 ;
16440 int arg5 = (int) -1 ;
16441 int arg6 = (int) -1 ;
16442 wxImage *result = 0 ;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 wxSize temp2 ;
16446 wxPoint temp3 ;
16447 int val4 ;
16448 int ecode4 = 0 ;
16449 int val5 ;
16450 int ecode5 = 0 ;
16451 int val6 ;
16452 int ecode6 = 0 ;
16453 PyObject * obj0 = 0 ;
16454 PyObject * obj1 = 0 ;
16455 PyObject * obj2 = 0 ;
16456 PyObject * obj3 = 0 ;
16457 PyObject * obj4 = 0 ;
16458 PyObject * obj5 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16467 }
16468 arg1 = reinterpret_cast< wxImage * >(argp1);
16469 {
16470 arg2 = &temp2;
16471 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16472 }
16473 {
16474 arg3 = &temp3;
16475 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16476 }
16477 if (obj3) {
16478 ecode4 = SWIG_AsVal_int(obj3, &val4);
16479 if (!SWIG_IsOK(ecode4)) {
16480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16481 }
16482 arg4 = static_cast< int >(val4);
16483 }
16484 if (obj4) {
16485 ecode5 = SWIG_AsVal_int(obj4, &val5);
16486 if (!SWIG_IsOK(ecode5)) {
16487 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16488 }
16489 arg5 = static_cast< int >(val5);
16490 }
16491 if (obj5) {
16492 ecode6 = SWIG_AsVal_int(obj5, &val6);
16493 if (!SWIG_IsOK(ecode6)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16495 }
16496 arg6 = static_cast< int >(val6);
16497 }
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 {
16501 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16502 result = (wxImage *) &_result_ref;
16503 }
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj = 0;
16516 wxImage *arg1 = (wxImage *) 0 ;
16517 int arg2 ;
16518 int arg3 ;
16519 byte arg4 ;
16520 byte arg5 ;
16521 byte arg6 ;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 int val2 ;
16525 int ecode2 = 0 ;
16526 int val3 ;
16527 int ecode3 = 0 ;
16528 unsigned char val4 ;
16529 int ecode4 = 0 ;
16530 unsigned char val5 ;
16531 int ecode5 = 0 ;
16532 unsigned char val6 ;
16533 int ecode6 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 PyObject * obj2 = 0 ;
16537 PyObject * obj3 = 0 ;
16538 PyObject * obj4 = 0 ;
16539 PyObject * obj5 = 0 ;
16540 char * kwnames[] = {
16541 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16542 };
16543
16544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16546 if (!SWIG_IsOK(res1)) {
16547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16548 }
16549 arg1 = reinterpret_cast< wxImage * >(argp1);
16550 ecode2 = SWIG_AsVal_int(obj1, &val2);
16551 if (!SWIG_IsOK(ecode2)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16553 }
16554 arg2 = static_cast< int >(val2);
16555 ecode3 = SWIG_AsVal_int(obj2, &val3);
16556 if (!SWIG_IsOK(ecode3)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16558 }
16559 arg3 = static_cast< int >(val3);
16560 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16561 if (!SWIG_IsOK(ecode4)) {
16562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16563 }
16564 arg4 = static_cast< byte >(val4);
16565 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16566 if (!SWIG_IsOK(ecode5)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16568 }
16569 arg5 = static_cast< byte >(val5);
16570 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16571 if (!SWIG_IsOK(ecode6)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16573 }
16574 arg6 = static_cast< byte >(val6);
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16578 wxPyEndAllowThreads(__tstate);
16579 if (PyErr_Occurred()) SWIG_fail;
16580 }
16581 resultobj = SWIG_Py_Void();
16582 return resultobj;
16583 fail:
16584 return NULL;
16585 }
16586
16587
16588 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16589 PyObject *resultobj = 0;
16590 wxImage *arg1 = (wxImage *) 0 ;
16591 wxRect *arg2 = 0 ;
16592 byte arg3 ;
16593 byte arg4 ;
16594 byte arg5 ;
16595 void *argp1 = 0 ;
16596 int res1 = 0 ;
16597 wxRect temp2 ;
16598 unsigned char val3 ;
16599 int ecode3 = 0 ;
16600 unsigned char val4 ;
16601 int ecode4 = 0 ;
16602 unsigned char val5 ;
16603 int ecode5 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 PyObject * obj2 = 0 ;
16607 PyObject * obj3 = 0 ;
16608 PyObject * obj4 = 0 ;
16609 char * kwnames[] = {
16610 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16611 };
16612
16613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16617 }
16618 arg1 = reinterpret_cast< wxImage * >(argp1);
16619 {
16620 arg2 = &temp2;
16621 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16622 }
16623 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16624 if (!SWIG_IsOK(ecode3)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16626 }
16627 arg3 = static_cast< byte >(val3);
16628 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16629 if (!SWIG_IsOK(ecode4)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16631 }
16632 arg4 = static_cast< byte >(val4);
16633 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16634 if (!SWIG_IsOK(ecode5)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16636 }
16637 arg5 = static_cast< byte >(val5);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 resultobj = SWIG_Py_Void();
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj = 0;
16653 wxImage *arg1 = (wxImage *) 0 ;
16654 int arg2 ;
16655 int arg3 ;
16656 byte result;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 int val2 ;
16660 int ecode2 = 0 ;
16661 int val3 ;
16662 int ecode3 = 0 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 PyObject * obj2 = 0 ;
16666 char * kwnames[] = {
16667 (char *) "self",(char *) "x",(char *) "y", NULL
16668 };
16669
16670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16672 if (!SWIG_IsOK(res1)) {
16673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16674 }
16675 arg1 = reinterpret_cast< wxImage * >(argp1);
16676 ecode2 = SWIG_AsVal_int(obj1, &val2);
16677 if (!SWIG_IsOK(ecode2)) {
16678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16679 }
16680 arg2 = static_cast< int >(val2);
16681 ecode3 = SWIG_AsVal_int(obj2, &val3);
16682 if (!SWIG_IsOK(ecode3)) {
16683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16684 }
16685 arg3 = static_cast< int >(val3);
16686 {
16687 PyThreadState* __tstate = wxPyBeginAllowThreads();
16688 result = (byte)(arg1)->GetRed(arg2,arg3);
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16693 return resultobj;
16694 fail:
16695 return NULL;
16696 }
16697
16698
16699 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16700 PyObject *resultobj = 0;
16701 wxImage *arg1 = (wxImage *) 0 ;
16702 int arg2 ;
16703 int arg3 ;
16704 byte result;
16705 void *argp1 = 0 ;
16706 int res1 = 0 ;
16707 int val2 ;
16708 int ecode2 = 0 ;
16709 int val3 ;
16710 int ecode3 = 0 ;
16711 PyObject * obj0 = 0 ;
16712 PyObject * obj1 = 0 ;
16713 PyObject * obj2 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "x",(char *) "y", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16722 }
16723 arg1 = reinterpret_cast< wxImage * >(argp1);
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 ecode3 = SWIG_AsVal_int(obj2, &val3);
16730 if (!SWIG_IsOK(ecode3)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16732 }
16733 arg3 = static_cast< int >(val3);
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = (byte)(arg1)->GetGreen(arg2,arg3);
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj = 0;
16749 wxImage *arg1 = (wxImage *) 0 ;
16750 int arg2 ;
16751 int arg3 ;
16752 byte result;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 int val2 ;
16756 int ecode2 = 0 ;
16757 int val3 ;
16758 int ecode3 = 0 ;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 PyObject * obj2 = 0 ;
16762 char * kwnames[] = {
16763 (char *) "self",(char *) "x",(char *) "y", NULL
16764 };
16765
16766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16768 if (!SWIG_IsOK(res1)) {
16769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16770 }
16771 arg1 = reinterpret_cast< wxImage * >(argp1);
16772 ecode2 = SWIG_AsVal_int(obj1, &val2);
16773 if (!SWIG_IsOK(ecode2)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16775 }
16776 arg2 = static_cast< int >(val2);
16777 ecode3 = SWIG_AsVal_int(obj2, &val3);
16778 if (!SWIG_IsOK(ecode3)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16780 }
16781 arg3 = static_cast< int >(val3);
16782 {
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 result = (byte)(arg1)->GetBlue(arg2,arg3);
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj = 0;
16797 wxImage *arg1 = (wxImage *) 0 ;
16798 int arg2 ;
16799 int arg3 ;
16800 byte arg4 ;
16801 void *argp1 = 0 ;
16802 int res1 = 0 ;
16803 int val2 ;
16804 int ecode2 = 0 ;
16805 int val3 ;
16806 int ecode3 = 0 ;
16807 unsigned char val4 ;
16808 int ecode4 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 PyObject * obj1 = 0 ;
16811 PyObject * obj2 = 0 ;
16812 PyObject * obj3 = 0 ;
16813 char * kwnames[] = {
16814 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16815 };
16816
16817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16819 if (!SWIG_IsOK(res1)) {
16820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16821 }
16822 arg1 = reinterpret_cast< wxImage * >(argp1);
16823 ecode2 = SWIG_AsVal_int(obj1, &val2);
16824 if (!SWIG_IsOK(ecode2)) {
16825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16826 }
16827 arg2 = static_cast< int >(val2);
16828 ecode3 = SWIG_AsVal_int(obj2, &val3);
16829 if (!SWIG_IsOK(ecode3)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16831 }
16832 arg3 = static_cast< int >(val3);
16833 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16834 if (!SWIG_IsOK(ecode4)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16836 }
16837 arg4 = static_cast< byte >(val4);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 (arg1)->SetAlpha(arg2,arg3,arg4);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_Py_Void();
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxImage *arg1 = (wxImage *) 0 ;
16854 int arg2 ;
16855 int arg3 ;
16856 byte result;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 int val2 ;
16860 int ecode2 = 0 ;
16861 int val3 ;
16862 int ecode3 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 PyObject * obj2 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "x",(char *) "y", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16874 }
16875 arg1 = reinterpret_cast< wxImage * >(argp1);
16876 ecode2 = SWIG_AsVal_int(obj1, &val2);
16877 if (!SWIG_IsOK(ecode2)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16879 }
16880 arg2 = static_cast< int >(val2);
16881 ecode3 = SWIG_AsVal_int(obj2, &val3);
16882 if (!SWIG_IsOK(ecode3)) {
16883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16884 }
16885 arg3 = static_cast< int >(val3);
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16900 PyObject *resultobj = 0;
16901 wxImage *arg1 = (wxImage *) 0 ;
16902 bool result;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 PyObject *swig_obj[1] ;
16906
16907 if (!args) SWIG_fail;
16908 swig_obj[0] = args;
16909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16912 }
16913 arg1 = reinterpret_cast< wxImage * >(argp1);
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)(arg1)->HasAlpha();
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 {
16921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16922 }
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16930 PyObject *resultobj = 0;
16931 wxImage *arg1 = (wxImage *) 0 ;
16932 void *argp1 = 0 ;
16933 int res1 = 0 ;
16934 PyObject *swig_obj[1] ;
16935
16936 if (!args) SWIG_fail;
16937 swig_obj[0] = args;
16938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16939 if (!SWIG_IsOK(res1)) {
16940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16941 }
16942 arg1 = reinterpret_cast< wxImage * >(argp1);
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 (arg1)->InitAlpha();
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_Py_Void();
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 wxImage *arg1 = (wxImage *) 0 ;
16959 int arg2 ;
16960 int arg3 ;
16961 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16962 bool result;
16963 void *argp1 = 0 ;
16964 int res1 = 0 ;
16965 int val2 ;
16966 int ecode2 = 0 ;
16967 int val3 ;
16968 int ecode3 = 0 ;
16969 unsigned char val4 ;
16970 int ecode4 = 0 ;
16971 PyObject * obj0 = 0 ;
16972 PyObject * obj1 = 0 ;
16973 PyObject * obj2 = 0 ;
16974 PyObject * obj3 = 0 ;
16975 char * kwnames[] = {
16976 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16977 };
16978
16979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16983 }
16984 arg1 = reinterpret_cast< wxImage * >(argp1);
16985 ecode2 = SWIG_AsVal_int(obj1, &val2);
16986 if (!SWIG_IsOK(ecode2)) {
16987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16988 }
16989 arg2 = static_cast< int >(val2);
16990 ecode3 = SWIG_AsVal_int(obj2, &val3);
16991 if (!SWIG_IsOK(ecode3)) {
16992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16993 }
16994 arg3 = static_cast< int >(val3);
16995 if (obj3) {
16996 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16997 if (!SWIG_IsOK(ecode4)) {
16998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16999 }
17000 arg4 = static_cast< byte >(val4);
17001 }
17002 {
17003 PyThreadState* __tstate = wxPyBeginAllowThreads();
17004 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17005 wxPyEndAllowThreads(__tstate);
17006 if (PyErr_Occurred()) SWIG_fail;
17007 }
17008 {
17009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17010 }
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj = 0;
17019 wxImage *arg1 = (wxImage *) 0 ;
17020 byte *arg2 = (byte *) 0 ;
17021 byte *arg3 = (byte *) 0 ;
17022 byte *arg4 = (byte *) 0 ;
17023 byte arg5 = (byte) 0 ;
17024 byte arg6 = (byte) 0 ;
17025 byte arg7 = (byte) 0 ;
17026 bool result;
17027 void *argp1 = 0 ;
17028 int res1 = 0 ;
17029 byte temp2 ;
17030 int res2 = SWIG_TMPOBJ ;
17031 byte temp3 ;
17032 int res3 = SWIG_TMPOBJ ;
17033 byte temp4 ;
17034 int res4 = SWIG_TMPOBJ ;
17035 unsigned char val5 ;
17036 int ecode5 = 0 ;
17037 unsigned char val6 ;
17038 int ecode6 = 0 ;
17039 unsigned char val7 ;
17040 int ecode7 = 0 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 PyObject * obj2 = 0 ;
17044 PyObject * obj3 = 0 ;
17045 char * kwnames[] = {
17046 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17047 };
17048
17049 arg2 = &temp2;
17050 arg3 = &temp3;
17051 arg4 = &temp4;
17052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17054 if (!SWIG_IsOK(res1)) {
17055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17056 }
17057 arg1 = reinterpret_cast< wxImage * >(argp1);
17058 if (obj1) {
17059 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17060 if (!SWIG_IsOK(ecode5)) {
17061 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17062 }
17063 arg5 = static_cast< byte >(val5);
17064 }
17065 if (obj2) {
17066 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17067 if (!SWIG_IsOK(ecode6)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17069 }
17070 arg6 = static_cast< byte >(val6);
17071 }
17072 if (obj3) {
17073 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17074 if (!SWIG_IsOK(ecode7)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17076 }
17077 arg7 = static_cast< byte >(val7);
17078 }
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 if (SWIG_IsTmpObj(res2)) {
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17090 } else {
17091 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17093 }
17094 if (SWIG_IsTmpObj(res3)) {
17095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17096 } else {
17097 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17099 }
17100 if (SWIG_IsTmpObj(res4)) {
17101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17102 } else {
17103 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17105 }
17106 return resultobj;
17107 fail:
17108 return NULL;
17109 }
17110
17111
17112 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj = 0;
17114 wxImage *arg1 = (wxImage *) 0 ;
17115 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17116 bool result;
17117 void *argp1 = 0 ;
17118 int res1 = 0 ;
17119 unsigned char val2 ;
17120 int ecode2 = 0 ;
17121 PyObject * obj0 = 0 ;
17122 PyObject * obj1 = 0 ;
17123 char * kwnames[] = {
17124 (char *) "self",(char *) "threshold", NULL
17125 };
17126
17127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17129 if (!SWIG_IsOK(res1)) {
17130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17131 }
17132 arg1 = reinterpret_cast< wxImage * >(argp1);
17133 if (obj1) {
17134 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17135 if (!SWIG_IsOK(ecode2)) {
17136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17137 }
17138 arg2 = static_cast< byte >(val2);
17139 }
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 {
17147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17148 }
17149 return resultobj;
17150 fail:
17151 return NULL;
17152 }
17153
17154
17155 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxImage *arg1 = (wxImage *) 0 ;
17158 byte arg2 ;
17159 byte arg3 ;
17160 byte arg4 ;
17161 bool result;
17162 void *argp1 = 0 ;
17163 int res1 = 0 ;
17164 unsigned char val2 ;
17165 int ecode2 = 0 ;
17166 unsigned char val3 ;
17167 int ecode3 = 0 ;
17168 unsigned char val4 ;
17169 int ecode4 = 0 ;
17170 PyObject * obj0 = 0 ;
17171 PyObject * obj1 = 0 ;
17172 PyObject * obj2 = 0 ;
17173 PyObject * obj3 = 0 ;
17174 char * kwnames[] = {
17175 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17176 };
17177
17178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17180 if (!SWIG_IsOK(res1)) {
17181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17182 }
17183 arg1 = reinterpret_cast< wxImage * >(argp1);
17184 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17185 if (!SWIG_IsOK(ecode2)) {
17186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17187 }
17188 arg2 = static_cast< byte >(val2);
17189 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17190 if (!SWIG_IsOK(ecode3)) {
17191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17192 }
17193 arg3 = static_cast< byte >(val3);
17194 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17195 if (!SWIG_IsOK(ecode4)) {
17196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17197 }
17198 arg4 = static_cast< byte >(val4);
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 {
17206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17207 }
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj = 0;
17216 wxImage *arg1 = (wxImage *) 0 ;
17217 wxImage *arg2 = 0 ;
17218 byte arg3 ;
17219 byte arg4 ;
17220 byte arg5 ;
17221 bool result;
17222 void *argp1 = 0 ;
17223 int res1 = 0 ;
17224 void *argp2 = 0 ;
17225 int res2 = 0 ;
17226 unsigned char val3 ;
17227 int ecode3 = 0 ;
17228 unsigned char val4 ;
17229 int ecode4 = 0 ;
17230 unsigned char val5 ;
17231 int ecode5 = 0 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 PyObject * obj2 = 0 ;
17235 PyObject * obj3 = 0 ;
17236 PyObject * obj4 = 0 ;
17237 char * kwnames[] = {
17238 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17239 };
17240
17241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17243 if (!SWIG_IsOK(res1)) {
17244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17245 }
17246 arg1 = reinterpret_cast< wxImage * >(argp1);
17247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17248 if (!SWIG_IsOK(res2)) {
17249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17250 }
17251 if (!argp2) {
17252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17253 }
17254 arg2 = reinterpret_cast< wxImage * >(argp2);
17255 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17256 if (!SWIG_IsOK(ecode3)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17258 }
17259 arg3 = static_cast< byte >(val3);
17260 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17261 if (!SWIG_IsOK(ecode4)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17263 }
17264 arg4 = static_cast< byte >(val4);
17265 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17266 if (!SWIG_IsOK(ecode5)) {
17267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17268 }
17269 arg5 = static_cast< byte >(val5);
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 {
17277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17278 }
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxString *arg1 = 0 ;
17288 bool result;
17289 bool temp1 = false ;
17290 PyObject * obj0 = 0 ;
17291 char * kwnames[] = {
17292 (char *) "filename", NULL
17293 };
17294
17295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17296 {
17297 arg1 = wxString_in_helper(obj0);
17298 if (arg1 == NULL) SWIG_fail;
17299 temp1 = true;
17300 }
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 {
17308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17309 }
17310 {
17311 if (temp1)
17312 delete arg1;
17313 }
17314 return resultobj;
17315 fail:
17316 {
17317 if (temp1)
17318 delete arg1;
17319 }
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj = 0;
17326 wxString *arg1 = 0 ;
17327 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17328 int result;
17329 bool temp1 = false ;
17330 long val2 ;
17331 int ecode2 = 0 ;
17332 PyObject * obj0 = 0 ;
17333 PyObject * obj1 = 0 ;
17334 char * kwnames[] = {
17335 (char *) "filename",(char *) "type", NULL
17336 };
17337
17338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17339 {
17340 arg1 = wxString_in_helper(obj0);
17341 if (arg1 == NULL) SWIG_fail;
17342 temp1 = true;
17343 }
17344 if (obj1) {
17345 ecode2 = SWIG_AsVal_long(obj1, &val2);
17346 if (!SWIG_IsOK(ecode2)) {
17347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17348 }
17349 arg2 = static_cast< long >(val2);
17350 }
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_From_int(static_cast< int >(result));
17358 {
17359 if (temp1)
17360 delete arg1;
17361 }
17362 return resultobj;
17363 fail:
17364 {
17365 if (temp1)
17366 delete arg1;
17367 }
17368 return NULL;
17369 }
17370
17371
17372 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj = 0;
17374 wxImage *arg1 = (wxImage *) 0 ;
17375 wxString *arg2 = 0 ;
17376 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17377 int arg4 = (int) -1 ;
17378 bool result;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 bool temp2 = false ;
17382 long val3 ;
17383 int ecode3 = 0 ;
17384 int val4 ;
17385 int ecode4 = 0 ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 PyObject * obj2 = 0 ;
17389 PyObject * obj3 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17396 if (!SWIG_IsOK(res1)) {
17397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17398 }
17399 arg1 = reinterpret_cast< wxImage * >(argp1);
17400 {
17401 arg2 = wxString_in_helper(obj1);
17402 if (arg2 == NULL) SWIG_fail;
17403 temp2 = true;
17404 }
17405 if (obj2) {
17406 ecode3 = SWIG_AsVal_long(obj2, &val3);
17407 if (!SWIG_IsOK(ecode3)) {
17408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17409 }
17410 arg3 = static_cast< long >(val3);
17411 }
17412 if (obj3) {
17413 ecode4 = SWIG_AsVal_int(obj3, &val4);
17414 if (!SWIG_IsOK(ecode4)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17416 }
17417 arg4 = static_cast< int >(val4);
17418 }
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17427 }
17428 {
17429 if (temp2)
17430 delete arg2;
17431 }
17432 return resultobj;
17433 fail:
17434 {
17435 if (temp2)
17436 delete arg2;
17437 }
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = 0;
17444 wxImage *arg1 = (wxImage *) 0 ;
17445 wxString *arg2 = 0 ;
17446 wxString *arg3 = 0 ;
17447 int arg4 = (int) -1 ;
17448 bool result;
17449 void *argp1 = 0 ;
17450 int res1 = 0 ;
17451 bool temp2 = false ;
17452 bool temp3 = false ;
17453 int val4 ;
17454 int ecode4 = 0 ;
17455 PyObject * obj0 = 0 ;
17456 PyObject * obj1 = 0 ;
17457 PyObject * obj2 = 0 ;
17458 PyObject * obj3 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17467 }
17468 arg1 = reinterpret_cast< wxImage * >(argp1);
17469 {
17470 arg2 = wxString_in_helper(obj1);
17471 if (arg2 == NULL) SWIG_fail;
17472 temp2 = true;
17473 }
17474 {
17475 arg3 = wxString_in_helper(obj2);
17476 if (arg3 == NULL) SWIG_fail;
17477 temp3 = true;
17478 }
17479 if (obj3) {
17480 ecode4 = SWIG_AsVal_int(obj3, &val4);
17481 if (!SWIG_IsOK(ecode4)) {
17482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17483 }
17484 arg4 = static_cast< int >(val4);
17485 }
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 {
17493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17494 }
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 {
17500 if (temp3)
17501 delete arg3;
17502 }
17503 return resultobj;
17504 fail:
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 {
17510 if (temp3)
17511 delete arg3;
17512 }
17513 return NULL;
17514 }
17515
17516
17517 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17518 PyObject *resultobj = 0;
17519 wxImage *arg1 = (wxImage *) 0 ;
17520 wxString *arg2 = 0 ;
17521 int arg3 ;
17522 bool result;
17523 void *argp1 = 0 ;
17524 int res1 = 0 ;
17525 bool temp2 = false ;
17526 int val3 ;
17527 int ecode3 = 0 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 PyObject * obj2 = 0 ;
17531 char * kwnames[] = {
17532 (char *) "self",(char *) "name",(char *) "type", NULL
17533 };
17534
17535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17539 }
17540 arg1 = reinterpret_cast< wxImage * >(argp1);
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 ecode3 = SWIG_AsVal_int(obj2, &val3);
17547 if (!SWIG_IsOK(ecode3)) {
17548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17549 }
17550 arg3 = static_cast< int >(val3);
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 {
17558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17559 }
17560 {
17561 if (temp2)
17562 delete arg2;
17563 }
17564 return resultobj;
17565 fail:
17566 {
17567 if (temp2)
17568 delete arg2;
17569 }
17570 return NULL;
17571 }
17572
17573
17574 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17575 PyObject *resultobj = 0;
17576 wxImage *arg1 = (wxImage *) 0 ;
17577 wxString *arg2 = 0 ;
17578 wxString *arg3 = 0 ;
17579 bool result;
17580 void *argp1 = 0 ;
17581 int res1 = 0 ;
17582 bool temp2 = false ;
17583 bool temp3 = false ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char * kwnames[] = {
17588 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17589 };
17590
17591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17593 if (!SWIG_IsOK(res1)) {
17594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17595 }
17596 arg1 = reinterpret_cast< wxImage * >(argp1);
17597 {
17598 arg2 = wxString_in_helper(obj1);
17599 if (arg2 == NULL) SWIG_fail;
17600 temp2 = true;
17601 }
17602 {
17603 arg3 = wxString_in_helper(obj2);
17604 if (arg3 == NULL) SWIG_fail;
17605 temp3 = true;
17606 }
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 {
17617 if (temp2)
17618 delete arg2;
17619 }
17620 {
17621 if (temp3)
17622 delete arg3;
17623 }
17624 return resultobj;
17625 fail:
17626 {
17627 if (temp2)
17628 delete arg2;
17629 }
17630 {
17631 if (temp3)
17632 delete arg3;
17633 }
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = 0;
17640 wxInputStream *arg1 = 0 ;
17641 bool result;
17642 wxPyInputStream *temp1 ;
17643 bool created1 ;
17644 PyObject * obj0 = 0 ;
17645 char * kwnames[] = {
17646 (char *) "stream", NULL
17647 };
17648
17649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17650 {
17651 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17652 arg1 = temp1->m_wxis;
17653 created1 = false;
17654 } else {
17655 PyErr_Clear(); // clear the failure of the wxPyConvert above
17656 arg1 = wxPyCBInputStream_create(obj0, false);
17657 if (arg1 == NULL) {
17658 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17659 SWIG_fail;
17660 }
17661 created1 = true;
17662 }
17663 }
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (bool)wxImage::CanRead(*arg1);
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 {
17671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17672 }
17673 {
17674 if (created1) delete arg1;
17675 }
17676 return resultobj;
17677 fail:
17678 {
17679 if (created1) delete arg1;
17680 }
17681 return NULL;
17682 }
17683
17684
17685 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj = 0;
17687 wxImage *arg1 = (wxImage *) 0 ;
17688 wxInputStream *arg2 = 0 ;
17689 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17690 int arg4 = (int) -1 ;
17691 bool result;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 wxPyInputStream *temp2 ;
17695 bool created2 ;
17696 long val3 ;
17697 int ecode3 = 0 ;
17698 int val4 ;
17699 int ecode4 = 0 ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 PyObject * obj2 = 0 ;
17703 PyObject * obj3 = 0 ;
17704 char * kwnames[] = {
17705 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17706 };
17707
17708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17710 if (!SWIG_IsOK(res1)) {
17711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17712 }
17713 arg1 = reinterpret_cast< wxImage * >(argp1);
17714 {
17715 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17716 arg2 = temp2->m_wxis;
17717 created2 = false;
17718 } else {
17719 PyErr_Clear(); // clear the failure of the wxPyConvert above
17720 arg2 = wxPyCBInputStream_create(obj1, false);
17721 if (arg2 == NULL) {
17722 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17723 SWIG_fail;
17724 }
17725 created2 = true;
17726 }
17727 }
17728 if (obj2) {
17729 ecode3 = SWIG_AsVal_long(obj2, &val3);
17730 if (!SWIG_IsOK(ecode3)) {
17731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17732 }
17733 arg3 = static_cast< long >(val3);
17734 }
17735 if (obj3) {
17736 ecode4 = SWIG_AsVal_int(obj3, &val4);
17737 if (!SWIG_IsOK(ecode4)) {
17738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17739 }
17740 arg4 = static_cast< int >(val4);
17741 }
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 {
17752 if (created2) delete arg2;
17753 }
17754 return resultobj;
17755 fail:
17756 {
17757 if (created2) delete arg2;
17758 }
17759 return NULL;
17760 }
17761
17762
17763 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj = 0;
17765 wxImage *arg1 = (wxImage *) 0 ;
17766 wxInputStream *arg2 = 0 ;
17767 wxString *arg3 = 0 ;
17768 int arg4 = (int) -1 ;
17769 bool result;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 wxPyInputStream *temp2 ;
17773 bool created2 ;
17774 bool temp3 = false ;
17775 int val4 ;
17776 int ecode4 = 0 ;
17777 PyObject * obj0 = 0 ;
17778 PyObject * obj1 = 0 ;
17779 PyObject * obj2 = 0 ;
17780 PyObject * obj3 = 0 ;
17781 char * kwnames[] = {
17782 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17783 };
17784
17785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17787 if (!SWIG_IsOK(res1)) {
17788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17789 }
17790 arg1 = reinterpret_cast< wxImage * >(argp1);
17791 {
17792 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17793 arg2 = temp2->m_wxis;
17794 created2 = false;
17795 } else {
17796 PyErr_Clear(); // clear the failure of the wxPyConvert above
17797 arg2 = wxPyCBInputStream_create(obj1, false);
17798 if (arg2 == NULL) {
17799 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17800 SWIG_fail;
17801 }
17802 created2 = true;
17803 }
17804 }
17805 {
17806 arg3 = wxString_in_helper(obj2);
17807 if (arg3 == NULL) SWIG_fail;
17808 temp3 = true;
17809 }
17810 if (obj3) {
17811 ecode4 = SWIG_AsVal_int(obj3, &val4);
17812 if (!SWIG_IsOK(ecode4)) {
17813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17814 }
17815 arg4 = static_cast< int >(val4);
17816 }
17817 {
17818 PyThreadState* __tstate = wxPyBeginAllowThreads();
17819 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17825 }
17826 {
17827 if (created2) delete arg2;
17828 }
17829 {
17830 if (temp3)
17831 delete arg3;
17832 }
17833 return resultobj;
17834 fail:
17835 {
17836 if (created2) delete arg2;
17837 }
17838 {
17839 if (temp3)
17840 delete arg3;
17841 }
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17847 PyObject *resultobj = 0;
17848 wxImage *arg1 = (wxImage *) 0 ;
17849 bool result;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 PyObject *swig_obj[1] ;
17853
17854 if (!args) SWIG_fail;
17855 swig_obj[0] = args;
17856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17859 }
17860 arg1 = reinterpret_cast< wxImage * >(argp1);
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (bool)(arg1)->IsOk();
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17869 }
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17877 PyObject *resultobj = 0;
17878 wxImage *arg1 = (wxImage *) 0 ;
17879 int result;
17880 void *argp1 = 0 ;
17881 int res1 = 0 ;
17882 PyObject *swig_obj[1] ;
17883
17884 if (!args) SWIG_fail;
17885 swig_obj[0] = args;
17886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17887 if (!SWIG_IsOK(res1)) {
17888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17889 }
17890 arg1 = reinterpret_cast< wxImage * >(argp1);
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (int)(arg1)->GetWidth();
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 resultobj = SWIG_From_int(static_cast< int >(result));
17898 return resultobj;
17899 fail:
17900 return NULL;
17901 }
17902
17903
17904 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905 PyObject *resultobj = 0;
17906 wxImage *arg1 = (wxImage *) 0 ;
17907 int result;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 PyObject *swig_obj[1] ;
17911
17912 if (!args) SWIG_fail;
17913 swig_obj[0] = args;
17914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17915 if (!SWIG_IsOK(res1)) {
17916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17917 }
17918 arg1 = reinterpret_cast< wxImage * >(argp1);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (int)(arg1)->GetHeight();
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 resultobj = SWIG_From_int(static_cast< int >(result));
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxImage *arg1 = (wxImage *) 0 ;
17935 wxSize result;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 PyObject *swig_obj[1] ;
17939
17940 if (!args) SWIG_fail;
17941 swig_obj[0] = args;
17942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17945 }
17946 arg1 = reinterpret_cast< wxImage * >(argp1);
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = wxImage_GetSize(arg1);
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj = 0;
17962 wxImage *arg1 = (wxImage *) 0 ;
17963 wxRect *arg2 = 0 ;
17964 SwigValueWrapper<wxImage > result;
17965 void *argp1 = 0 ;
17966 int res1 = 0 ;
17967 wxRect temp2 ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 char * kwnames[] = {
17971 (char *) "self",(char *) "rect", NULL
17972 };
17973
17974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17978 }
17979 arg1 = reinterpret_cast< wxImage * >(argp1);
17980 {
17981 arg2 = &temp2;
17982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17983 }
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj = 0;
17999 wxImage *arg1 = (wxImage *) 0 ;
18000 wxSize *arg2 = 0 ;
18001 wxPoint *arg3 = 0 ;
18002 int arg4 = (int) -1 ;
18003 int arg5 = (int) -1 ;
18004 int arg6 = (int) -1 ;
18005 SwigValueWrapper<wxImage > result;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 wxSize temp2 ;
18009 wxPoint temp3 ;
18010 int val4 ;
18011 int ecode4 = 0 ;
18012 int val5 ;
18013 int ecode5 = 0 ;
18014 int val6 ;
18015 int ecode6 = 0 ;
18016 PyObject * obj0 = 0 ;
18017 PyObject * obj1 = 0 ;
18018 PyObject * obj2 = 0 ;
18019 PyObject * obj3 = 0 ;
18020 PyObject * obj4 = 0 ;
18021 PyObject * obj5 = 0 ;
18022 char * kwnames[] = {
18023 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18024 };
18025
18026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18030 }
18031 arg1 = reinterpret_cast< wxImage * >(argp1);
18032 {
18033 arg2 = &temp2;
18034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18035 }
18036 {
18037 arg3 = &temp3;
18038 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18039 }
18040 if (obj3) {
18041 ecode4 = SWIG_AsVal_int(obj3, &val4);
18042 if (!SWIG_IsOK(ecode4)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18044 }
18045 arg4 = static_cast< int >(val4);
18046 }
18047 if (obj4) {
18048 ecode5 = SWIG_AsVal_int(obj4, &val5);
18049 if (!SWIG_IsOK(ecode5)) {
18050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18051 }
18052 arg5 = static_cast< int >(val5);
18053 }
18054 if (obj5) {
18055 ecode6 = SWIG_AsVal_int(obj5, &val6);
18056 if (!SWIG_IsOK(ecode6)) {
18057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18058 }
18059 arg6 = static_cast< int >(val6);
18060 }
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18068 return resultobj;
18069 fail:
18070 return NULL;
18071 }
18072
18073
18074 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18075 PyObject *resultobj = 0;
18076 wxImage *arg1 = (wxImage *) 0 ;
18077 SwigValueWrapper<wxImage > result;
18078 void *argp1 = 0 ;
18079 int res1 = 0 ;
18080 PyObject *swig_obj[1] ;
18081
18082 if (!args) SWIG_fail;
18083 swig_obj[0] = args;
18084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18087 }
18088 arg1 = reinterpret_cast< wxImage * >(argp1);
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (arg1)->Copy();
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18096 return resultobj;
18097 fail:
18098 return NULL;
18099 }
18100
18101
18102 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj = 0;
18104 wxImage *arg1 = (wxImage *) 0 ;
18105 wxImage *arg2 = 0 ;
18106 int arg3 ;
18107 int arg4 ;
18108 void *argp1 = 0 ;
18109 int res1 = 0 ;
18110 void *argp2 = 0 ;
18111 int res2 = 0 ;
18112 int val3 ;
18113 int ecode3 = 0 ;
18114 int val4 ;
18115 int ecode4 = 0 ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 PyObject * obj2 = 0 ;
18119 PyObject * obj3 = 0 ;
18120 char * kwnames[] = {
18121 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18122 };
18123
18124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18126 if (!SWIG_IsOK(res1)) {
18127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18128 }
18129 arg1 = reinterpret_cast< wxImage * >(argp1);
18130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18131 if (!SWIG_IsOK(res2)) {
18132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18133 }
18134 if (!argp2) {
18135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18136 }
18137 arg2 = reinterpret_cast< wxImage * >(argp2);
18138 ecode3 = SWIG_AsVal_int(obj2, &val3);
18139 if (!SWIG_IsOK(ecode3)) {
18140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18141 }
18142 arg3 = static_cast< int >(val3);
18143 ecode4 = SWIG_AsVal_int(obj3, &val4);
18144 if (!SWIG_IsOK(ecode4)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18146 }
18147 arg4 = static_cast< int >(val4);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_Py_Void();
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18162 PyObject *resultobj = 0;
18163 wxImage *arg1 = (wxImage *) 0 ;
18164 PyObject *result = 0 ;
18165 void *argp1 = 0 ;
18166 int res1 = 0 ;
18167 PyObject *swig_obj[1] ;
18168
18169 if (!args) SWIG_fail;
18170 swig_obj[0] = args;
18171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18172 if (!SWIG_IsOK(res1)) {
18173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18174 }
18175 arg1 = reinterpret_cast< wxImage * >(argp1);
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 result = (PyObject *)wxImage_GetData(arg1);
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 resultobj = result;
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj = 0;
18191 wxImage *arg1 = (wxImage *) 0 ;
18192 buffer arg2 ;
18193 int arg3 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 Py_ssize_t temp2 ;
18197 PyObject * obj0 = 0 ;
18198 PyObject * obj1 = 0 ;
18199 char * kwnames[] = {
18200 (char *) "self",(char *) "data", NULL
18201 };
18202
18203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18205 if (!SWIG_IsOK(res1)) {
18206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18207 }
18208 arg1 = reinterpret_cast< wxImage * >(argp1);
18209 {
18210 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18211 arg3 = (int)temp2;
18212 }
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 wxImage_SetData(arg1,arg2,arg3);
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = SWIG_Py_Void();
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *resultobj = 0;
18228 wxImage *arg1 = (wxImage *) 0 ;
18229 PyObject *result = 0 ;
18230 void *argp1 = 0 ;
18231 int res1 = 0 ;
18232 PyObject *swig_obj[1] ;
18233
18234 if (!args) SWIG_fail;
18235 swig_obj[0] = args;
18236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18237 if (!SWIG_IsOK(res1)) {
18238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18239 }
18240 arg1 = reinterpret_cast< wxImage * >(argp1);
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = result;
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj = 0;
18256 wxImage *arg1 = (wxImage *) 0 ;
18257 buffer arg2 ;
18258 int arg3 ;
18259 void *argp1 = 0 ;
18260 int res1 = 0 ;
18261 Py_ssize_t temp2 ;
18262 PyObject * obj0 = 0 ;
18263 PyObject * obj1 = 0 ;
18264 char * kwnames[] = {
18265 (char *) "self",(char *) "data", NULL
18266 };
18267
18268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18270 if (!SWIG_IsOK(res1)) {
18271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18272 }
18273 arg1 = reinterpret_cast< wxImage * >(argp1);
18274 {
18275 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18276 arg3 = (int)temp2;
18277 }
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 wxImage_SetDataBuffer(arg1,arg2,arg3);
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = SWIG_Py_Void();
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292 PyObject *resultobj = 0;
18293 wxImage *arg1 = (wxImage *) 0 ;
18294 PyObject *result = 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 PyObject *swig_obj[1] ;
18298
18299 if (!args) SWIG_fail;
18300 swig_obj[0] = args;
18301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18304 }
18305 arg1 = reinterpret_cast< wxImage * >(argp1);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 result = (PyObject *)wxImage_GetAlphaData(arg1);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = result;
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj = 0;
18321 wxImage *arg1 = (wxImage *) 0 ;
18322 buffer arg2 ;
18323 int arg3 ;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
18326 Py_ssize_t temp2 ;
18327 PyObject * obj0 = 0 ;
18328 PyObject * obj1 = 0 ;
18329 char * kwnames[] = {
18330 (char *) "self",(char *) "alpha", NULL
18331 };
18332
18333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18335 if (!SWIG_IsOK(res1)) {
18336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18337 }
18338 arg1 = reinterpret_cast< wxImage * >(argp1);
18339 {
18340 if (obj1 != Py_None) {
18341 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18342 arg3 = (int)temp2;
18343 }
18344 }
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 wxImage_SetAlphaData(arg1,arg2,arg3);
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_Py_Void();
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18359 PyObject *resultobj = 0;
18360 wxImage *arg1 = (wxImage *) 0 ;
18361 PyObject *result = 0 ;
18362 void *argp1 = 0 ;
18363 int res1 = 0 ;
18364 PyObject *swig_obj[1] ;
18365
18366 if (!args) SWIG_fail;
18367 swig_obj[0] = args;
18368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18371 }
18372 arg1 = reinterpret_cast< wxImage * >(argp1);
18373 {
18374 PyThreadState* __tstate = wxPyBeginAllowThreads();
18375 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18376 wxPyEndAllowThreads(__tstate);
18377 if (PyErr_Occurred()) SWIG_fail;
18378 }
18379 resultobj = result;
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj = 0;
18388 wxImage *arg1 = (wxImage *) 0 ;
18389 buffer arg2 ;
18390 int arg3 ;
18391 void *argp1 = 0 ;
18392 int res1 = 0 ;
18393 Py_ssize_t temp2 ;
18394 PyObject * obj0 = 0 ;
18395 PyObject * obj1 = 0 ;
18396 char * kwnames[] = {
18397 (char *) "self",(char *) "alpha", NULL
18398 };
18399
18400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18402 if (!SWIG_IsOK(res1)) {
18403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18404 }
18405 arg1 = reinterpret_cast< wxImage * >(argp1);
18406 {
18407 if (obj1 != Py_None) {
18408 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18409 arg3 = (int)temp2;
18410 }
18411 }
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = SWIG_Py_Void();
18419 return resultobj;
18420 fail:
18421 return NULL;
18422 }
18423
18424
18425 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18426 PyObject *resultobj = 0;
18427 wxImage *arg1 = (wxImage *) 0 ;
18428 byte arg2 ;
18429 byte arg3 ;
18430 byte arg4 ;
18431 void *argp1 = 0 ;
18432 int res1 = 0 ;
18433 unsigned char val2 ;
18434 int ecode2 = 0 ;
18435 unsigned char val3 ;
18436 int ecode3 = 0 ;
18437 unsigned char val4 ;
18438 int ecode4 = 0 ;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 PyObject * obj2 = 0 ;
18442 PyObject * obj3 = 0 ;
18443 char * kwnames[] = {
18444 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18445 };
18446
18447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18449 if (!SWIG_IsOK(res1)) {
18450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18451 }
18452 arg1 = reinterpret_cast< wxImage * >(argp1);
18453 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18454 if (!SWIG_IsOK(ecode2)) {
18455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18456 }
18457 arg2 = static_cast< byte >(val2);
18458 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18459 if (!SWIG_IsOK(ecode3)) {
18460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18461 }
18462 arg3 = static_cast< byte >(val3);
18463 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18464 if (!SWIG_IsOK(ecode4)) {
18465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18466 }
18467 arg4 = static_cast< byte >(val4);
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 (arg1)->SetMaskColour(arg2,arg3,arg4);
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 resultobj = SWIG_Py_Void();
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18482 PyObject *resultobj = 0;
18483 wxImage *arg1 = (wxImage *) 0 ;
18484 byte *arg2 = (byte *) 0 ;
18485 byte *arg3 = (byte *) 0 ;
18486 byte *arg4 = (byte *) 0 ;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 byte temp2 ;
18490 int res2 = SWIG_TMPOBJ ;
18491 byte temp3 ;
18492 int res3 = SWIG_TMPOBJ ;
18493 byte temp4 ;
18494 int res4 = SWIG_TMPOBJ ;
18495 PyObject *swig_obj[1] ;
18496
18497 arg2 = &temp2;
18498 arg3 = &temp3;
18499 arg4 = &temp4;
18500 if (!args) SWIG_fail;
18501 swig_obj[0] = args;
18502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18505 }
18506 arg1 = reinterpret_cast< wxImage * >(argp1);
18507 {
18508 PyThreadState* __tstate = wxPyBeginAllowThreads();
18509 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 resultobj = SWIG_Py_Void();
18514 if (SWIG_IsTmpObj(res2)) {
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18516 } else {
18517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18519 }
18520 if (SWIG_IsTmpObj(res3)) {
18521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18522 } else {
18523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18525 }
18526 if (SWIG_IsTmpObj(res4)) {
18527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18528 } else {
18529 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18531 }
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18539 PyObject *resultobj = 0;
18540 wxImage *arg1 = (wxImage *) 0 ;
18541 byte result;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 PyObject *swig_obj[1] ;
18545
18546 if (!args) SWIG_fail;
18547 swig_obj[0] = args;
18548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18551 }
18552 arg1 = reinterpret_cast< wxImage * >(argp1);
18553 {
18554 PyThreadState* __tstate = wxPyBeginAllowThreads();
18555 result = (byte)(arg1)->GetMaskRed();
18556 wxPyEndAllowThreads(__tstate);
18557 if (PyErr_Occurred()) SWIG_fail;
18558 }
18559 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18560 return resultobj;
18561 fail:
18562 return NULL;
18563 }
18564
18565
18566 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18567 PyObject *resultobj = 0;
18568 wxImage *arg1 = (wxImage *) 0 ;
18569 byte result;
18570 void *argp1 = 0 ;
18571 int res1 = 0 ;
18572 PyObject *swig_obj[1] ;
18573
18574 if (!args) SWIG_fail;
18575 swig_obj[0] = args;
18576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18577 if (!SWIG_IsOK(res1)) {
18578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18579 }
18580 arg1 = reinterpret_cast< wxImage * >(argp1);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (byte)(arg1)->GetMaskGreen();
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxImage *arg1 = (wxImage *) 0 ;
18597 byte result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18607 }
18608 arg1 = reinterpret_cast< wxImage * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (byte)(arg1)->GetMaskBlue();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxImage *arg1 = (wxImage *) 0 ;
18625 bool arg2 = (bool) true ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 bool val2 ;
18629 int ecode2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "mask", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18640 }
18641 arg1 = reinterpret_cast< wxImage * >(argp1);
18642 if (obj1) {
18643 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18644 if (!SWIG_IsOK(ecode2)) {
18645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18646 }
18647 arg2 = static_cast< bool >(val2);
18648 }
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 (arg1)->SetMask(arg2);
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 resultobj = SWIG_Py_Void();
18656 return resultobj;
18657 fail:
18658 return NULL;
18659 }
18660
18661
18662 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18663 PyObject *resultobj = 0;
18664 wxImage *arg1 = (wxImage *) 0 ;
18665 bool result;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18675 }
18676 arg1 = reinterpret_cast< wxImage * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (bool)(arg1)->HasMask();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 {
18684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18685 }
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxImage *arg1 = (wxImage *) 0 ;
18695 double arg2 ;
18696 wxPoint *arg3 = 0 ;
18697 bool arg4 = (bool) true ;
18698 wxPoint *arg5 = (wxPoint *) NULL ;
18699 SwigValueWrapper<wxImage > result;
18700 void *argp1 = 0 ;
18701 int res1 = 0 ;
18702 double val2 ;
18703 int ecode2 = 0 ;
18704 wxPoint temp3 ;
18705 bool val4 ;
18706 int ecode4 = 0 ;
18707 void *argp5 = 0 ;
18708 int res5 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 PyObject * obj2 = 0 ;
18712 PyObject * obj3 = 0 ;
18713 PyObject * obj4 = 0 ;
18714 char * kwnames[] = {
18715 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18716 };
18717
18718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18722 }
18723 arg1 = reinterpret_cast< wxImage * >(argp1);
18724 ecode2 = SWIG_AsVal_double(obj1, &val2);
18725 if (!SWIG_IsOK(ecode2)) {
18726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18727 }
18728 arg2 = static_cast< double >(val2);
18729 {
18730 arg3 = &temp3;
18731 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18732 }
18733 if (obj3) {
18734 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18735 if (!SWIG_IsOK(ecode4)) {
18736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18737 }
18738 arg4 = static_cast< bool >(val4);
18739 }
18740 if (obj4) {
18741 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18742 if (!SWIG_IsOK(res5)) {
18743 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18744 }
18745 arg5 = reinterpret_cast< wxPoint * >(argp5);
18746 }
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj = 0;
18762 wxImage *arg1 = (wxImage *) 0 ;
18763 bool arg2 = (bool) true ;
18764 SwigValueWrapper<wxImage > result;
18765 void *argp1 = 0 ;
18766 int res1 = 0 ;
18767 bool val2 ;
18768 int ecode2 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "clockwise", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18779 }
18780 arg1 = reinterpret_cast< wxImage * >(argp1);
18781 if (obj1) {
18782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18783 if (!SWIG_IsOK(ecode2)) {
18784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18785 }
18786 arg2 = static_cast< bool >(val2);
18787 }
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (arg1)->Rotate90(arg2);
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj = 0;
18803 wxImage *arg1 = (wxImage *) 0 ;
18804 bool arg2 = (bool) true ;
18805 SwigValueWrapper<wxImage > result;
18806 void *argp1 = 0 ;
18807 int res1 = 0 ;
18808 bool val2 ;
18809 int ecode2 = 0 ;
18810 PyObject * obj0 = 0 ;
18811 PyObject * obj1 = 0 ;
18812 char * kwnames[] = {
18813 (char *) "self",(char *) "horizontally", NULL
18814 };
18815
18816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18818 if (!SWIG_IsOK(res1)) {
18819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18820 }
18821 arg1 = reinterpret_cast< wxImage * >(argp1);
18822 if (obj1) {
18823 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18824 if (!SWIG_IsOK(ecode2)) {
18825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18826 }
18827 arg2 = static_cast< bool >(val2);
18828 }
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 result = (arg1)->Mirror(arg2);
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = 0;
18844 wxImage *arg1 = (wxImage *) 0 ;
18845 byte arg2 ;
18846 byte arg3 ;
18847 byte arg4 ;
18848 byte arg5 ;
18849 byte arg6 ;
18850 byte arg7 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 unsigned char val2 ;
18854 int ecode2 = 0 ;
18855 unsigned char val3 ;
18856 int ecode3 = 0 ;
18857 unsigned char val4 ;
18858 int ecode4 = 0 ;
18859 unsigned char val5 ;
18860 int ecode5 = 0 ;
18861 unsigned char val6 ;
18862 int ecode6 = 0 ;
18863 unsigned char val7 ;
18864 int ecode7 = 0 ;
18865 PyObject * obj0 = 0 ;
18866 PyObject * obj1 = 0 ;
18867 PyObject * obj2 = 0 ;
18868 PyObject * obj3 = 0 ;
18869 PyObject * obj4 = 0 ;
18870 PyObject * obj5 = 0 ;
18871 PyObject * obj6 = 0 ;
18872 char * kwnames[] = {
18873 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18874 };
18875
18876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18880 }
18881 arg1 = reinterpret_cast< wxImage * >(argp1);
18882 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18883 if (!SWIG_IsOK(ecode2)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18885 }
18886 arg2 = static_cast< byte >(val2);
18887 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18888 if (!SWIG_IsOK(ecode3)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18890 }
18891 arg3 = static_cast< byte >(val3);
18892 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18893 if (!SWIG_IsOK(ecode4)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18895 }
18896 arg4 = static_cast< byte >(val4);
18897 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18898 if (!SWIG_IsOK(ecode5)) {
18899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18900 }
18901 arg5 = static_cast< byte >(val5);
18902 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18903 if (!SWIG_IsOK(ecode6)) {
18904 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18905 }
18906 arg6 = static_cast< byte >(val6);
18907 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18908 if (!SWIG_IsOK(ecode7)) {
18909 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18910 }
18911 arg7 = static_cast< byte >(val7);
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 resultobj = SWIG_Py_Void();
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxImage *arg1 = (wxImage *) 0 ;
18928 double arg2 = (double) 0.299 ;
18929 double arg3 = (double) 0.587 ;
18930 double arg4 = (double) 0.114 ;
18931 SwigValueWrapper<wxImage > result;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 double val2 ;
18935 int ecode2 = 0 ;
18936 double val3 ;
18937 int ecode3 = 0 ;
18938 double val4 ;
18939 int ecode4 = 0 ;
18940 PyObject * obj0 = 0 ;
18941 PyObject * obj1 = 0 ;
18942 PyObject * obj2 = 0 ;
18943 PyObject * obj3 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18952 }
18953 arg1 = reinterpret_cast< wxImage * >(argp1);
18954 if (obj1) {
18955 ecode2 = SWIG_AsVal_double(obj1, &val2);
18956 if (!SWIG_IsOK(ecode2)) {
18957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18958 }
18959 arg2 = static_cast< double >(val2);
18960 }
18961 if (obj2) {
18962 ecode3 = SWIG_AsVal_double(obj2, &val3);
18963 if (!SWIG_IsOK(ecode3)) {
18964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18965 }
18966 arg3 = static_cast< double >(val3);
18967 }
18968 if (obj3) {
18969 ecode4 = SWIG_AsVal_double(obj3, &val4);
18970 if (!SWIG_IsOK(ecode4)) {
18971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18972 }
18973 arg4 = static_cast< double >(val4);
18974 }
18975 {
18976 PyThreadState* __tstate = wxPyBeginAllowThreads();
18977 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18978 wxPyEndAllowThreads(__tstate);
18979 if (PyErr_Occurred()) SWIG_fail;
18980 }
18981 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18982 return resultobj;
18983 fail:
18984 return NULL;
18985 }
18986
18987
18988 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj = 0;
18990 wxImage *arg1 = (wxImage *) 0 ;
18991 byte arg2 ;
18992 byte arg3 ;
18993 byte arg4 ;
18994 SwigValueWrapper<wxImage > result;
18995 void *argp1 = 0 ;
18996 int res1 = 0 ;
18997 unsigned char val2 ;
18998 int ecode2 = 0 ;
18999 unsigned char val3 ;
19000 int ecode3 = 0 ;
19001 unsigned char val4 ;
19002 int ecode4 = 0 ;
19003 PyObject * obj0 = 0 ;
19004 PyObject * obj1 = 0 ;
19005 PyObject * obj2 = 0 ;
19006 PyObject * obj3 = 0 ;
19007 char * kwnames[] = {
19008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19009 };
19010
19011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19013 if (!SWIG_IsOK(res1)) {
19014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19015 }
19016 arg1 = reinterpret_cast< wxImage * >(argp1);
19017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19018 if (!SWIG_IsOK(ecode2)) {
19019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19020 }
19021 arg2 = static_cast< byte >(val2);
19022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19023 if (!SWIG_IsOK(ecode3)) {
19024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19025 }
19026 arg3 = static_cast< byte >(val3);
19027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19028 if (!SWIG_IsOK(ecode4)) {
19029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19030 }
19031 arg4 = static_cast< byte >(val4);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj = 0;
19047 wxImage *arg1 = (wxImage *) 0 ;
19048 wxString *arg2 = 0 ;
19049 wxString *arg3 = 0 ;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 bool temp2 = false ;
19053 bool temp3 = false ;
19054 PyObject * obj0 = 0 ;
19055 PyObject * obj1 = 0 ;
19056 PyObject * obj2 = 0 ;
19057 char * kwnames[] = {
19058 (char *) "self",(char *) "name",(char *) "value", NULL
19059 };
19060
19061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19065 }
19066 arg1 = reinterpret_cast< wxImage * >(argp1);
19067 {
19068 arg2 = wxString_in_helper(obj1);
19069 if (arg2 == NULL) SWIG_fail;
19070 temp2 = true;
19071 }
19072 {
19073 arg3 = wxString_in_helper(obj2);
19074 if (arg3 == NULL) SWIG_fail;
19075 temp3 = true;
19076 }
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 {
19085 if (temp2)
19086 delete arg2;
19087 }
19088 {
19089 if (temp3)
19090 delete arg3;
19091 }
19092 return resultobj;
19093 fail:
19094 {
19095 if (temp2)
19096 delete arg2;
19097 }
19098 {
19099 if (temp3)
19100 delete arg3;
19101 }
19102 return NULL;
19103 }
19104
19105
19106 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxImage *arg1 = (wxImage *) 0 ;
19109 wxString *arg2 = 0 ;
19110 int arg3 ;
19111 void *argp1 = 0 ;
19112 int res1 = 0 ;
19113 bool temp2 = false ;
19114 int val3 ;
19115 int ecode3 = 0 ;
19116 PyObject * obj0 = 0 ;
19117 PyObject * obj1 = 0 ;
19118 PyObject * obj2 = 0 ;
19119 char * kwnames[] = {
19120 (char *) "self",(char *) "name",(char *) "value", NULL
19121 };
19122
19123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19125 if (!SWIG_IsOK(res1)) {
19126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19127 }
19128 arg1 = reinterpret_cast< wxImage * >(argp1);
19129 {
19130 arg2 = wxString_in_helper(obj1);
19131 if (arg2 == NULL) SWIG_fail;
19132 temp2 = true;
19133 }
19134 ecode3 = SWIG_AsVal_int(obj2, &val3);
19135 if (!SWIG_IsOK(ecode3)) {
19136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19137 }
19138 arg3 = static_cast< int >(val3);
19139 {
19140 PyThreadState* __tstate = wxPyBeginAllowThreads();
19141 (arg1)->SetOption((wxString const &)*arg2,arg3);
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 resultobj = SWIG_Py_Void();
19146 {
19147 if (temp2)
19148 delete arg2;
19149 }
19150 return resultobj;
19151 fail:
19152 {
19153 if (temp2)
19154 delete arg2;
19155 }
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19161 PyObject *resultobj = 0;
19162 wxImage *arg1 = (wxImage *) 0 ;
19163 wxString *arg2 = 0 ;
19164 wxString result;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 bool temp2 = false ;
19168 PyObject * obj0 = 0 ;
19169 PyObject * obj1 = 0 ;
19170 char * kwnames[] = {
19171 (char *) "self",(char *) "name", NULL
19172 };
19173
19174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19178 }
19179 arg1 = reinterpret_cast< wxImage * >(argp1);
19180 {
19181 arg2 = wxString_in_helper(obj1);
19182 if (arg2 == NULL) SWIG_fail;
19183 temp2 = true;
19184 }
19185 {
19186 PyThreadState* __tstate = wxPyBeginAllowThreads();
19187 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 {
19192 #if wxUSE_UNICODE
19193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19194 #else
19195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19196 #endif
19197 }
19198 {
19199 if (temp2)
19200 delete arg2;
19201 }
19202 return resultobj;
19203 fail:
19204 {
19205 if (temp2)
19206 delete arg2;
19207 }
19208 return NULL;
19209 }
19210
19211
19212 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj = 0;
19214 wxImage *arg1 = (wxImage *) 0 ;
19215 wxString *arg2 = 0 ;
19216 int result;
19217 void *argp1 = 0 ;
19218 int res1 = 0 ;
19219 bool temp2 = false ;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 char * kwnames[] = {
19223 (char *) "self",(char *) "name", NULL
19224 };
19225
19226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19228 if (!SWIG_IsOK(res1)) {
19229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19230 }
19231 arg1 = reinterpret_cast< wxImage * >(argp1);
19232 {
19233 arg2 = wxString_in_helper(obj1);
19234 if (arg2 == NULL) SWIG_fail;
19235 temp2 = true;
19236 }
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_From_int(static_cast< int >(result));
19244 {
19245 if (temp2)
19246 delete arg2;
19247 }
19248 return resultobj;
19249 fail:
19250 {
19251 if (temp2)
19252 delete arg2;
19253 }
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxImage *arg1 = (wxImage *) 0 ;
19261 wxString *arg2 = 0 ;
19262 bool result;
19263 void *argp1 = 0 ;
19264 int res1 = 0 ;
19265 bool temp2 = false ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "self",(char *) "name", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19276 }
19277 arg1 = reinterpret_cast< wxImage * >(argp1);
19278 {
19279 arg2 = wxString_in_helper(obj1);
19280 if (arg2 == NULL) SWIG_fail;
19281 temp2 = true;
19282 }
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19291 }
19292 {
19293 if (temp2)
19294 delete arg2;
19295 }
19296 return resultobj;
19297 fail:
19298 {
19299 if (temp2)
19300 delete arg2;
19301 }
19302 return NULL;
19303 }
19304
19305
19306 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19307 PyObject *resultobj = 0;
19308 wxImage *arg1 = (wxImage *) 0 ;
19309 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19310 unsigned long result;
19311 void *argp1 = 0 ;
19312 int res1 = 0 ;
19313 unsigned long val2 ;
19314 int ecode2 = 0 ;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char * kwnames[] = {
19318 (char *) "self",(char *) "stopafter", NULL
19319 };
19320
19321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19323 if (!SWIG_IsOK(res1)) {
19324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19325 }
19326 arg1 = reinterpret_cast< wxImage * >(argp1);
19327 if (obj1) {
19328 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19329 if (!SWIG_IsOK(ecode2)) {
19330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19331 }
19332 arg2 = static_cast< unsigned long >(val2);
19333 }
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = (unsigned long)(arg1)->CountColours(arg2);
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19348 PyObject *resultobj = 0;
19349 wxImage *arg1 = (wxImage *) 0 ;
19350 wxImageHistogram *arg2 = 0 ;
19351 unsigned long result;
19352 void *argp1 = 0 ;
19353 int res1 = 0 ;
19354 void *argp2 = 0 ;
19355 int res2 = 0 ;
19356 PyObject * obj0 = 0 ;
19357 PyObject * obj1 = 0 ;
19358 char * kwnames[] = {
19359 (char *) "self",(char *) "h", NULL
19360 };
19361
19362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19364 if (!SWIG_IsOK(res1)) {
19365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19366 }
19367 arg1 = reinterpret_cast< wxImage * >(argp1);
19368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19369 if (!SWIG_IsOK(res2)) {
19370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19371 }
19372 if (!argp2) {
19373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19374 }
19375 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj = 0;
19391 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19392 void *argp1 = 0 ;
19393 int res1 = 0 ;
19394 PyObject * obj0 = 0 ;
19395 char * kwnames[] = {
19396 (char *) "handler", NULL
19397 };
19398
19399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19401 if (!SWIG_IsOK(res1)) {
19402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19403 }
19404 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 wxImage::AddHandler(arg1);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_Py_Void();
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19421 void *argp1 = 0 ;
19422 int res1 = 0 ;
19423 PyObject * obj0 = 0 ;
19424 char * kwnames[] = {
19425 (char *) "handler", NULL
19426 };
19427
19428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19430 if (!SWIG_IsOK(res1)) {
19431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19432 }
19433 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 wxImage::InsertHandler(arg1);
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_Py_Void();
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj = 0;
19449 wxString *arg1 = 0 ;
19450 bool result;
19451 bool temp1 = false ;
19452 PyObject * obj0 = 0 ;
19453 char * kwnames[] = {
19454 (char *) "name", NULL
19455 };
19456
19457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19458 {
19459 arg1 = wxString_in_helper(obj0);
19460 if (arg1 == NULL) SWIG_fail;
19461 temp1 = true;
19462 }
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 {
19470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19471 }
19472 {
19473 if (temp1)
19474 delete arg1;
19475 }
19476 return resultobj;
19477 fail:
19478 {
19479 if (temp1)
19480 delete arg1;
19481 }
19482 return NULL;
19483 }
19484
19485
19486 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 PyObject *result = 0 ;
19489
19490 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (PyObject *)wxImage_GetHandlers();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = result;
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *resultobj = 0;
19506 wxString result;
19507
19508 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 result = wxImage::GetImageExtWildcard();
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 {
19516 #if wxUSE_UNICODE
19517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19518 #else
19519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19520 #endif
19521 }
19522 return resultobj;
19523 fail:
19524 return NULL;
19525 }
19526
19527
19528 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19529 PyObject *resultobj = 0;
19530 wxImage *arg1 = (wxImage *) 0 ;
19531 int arg2 = (int) -1 ;
19532 wxBitmap result;
19533 void *argp1 = 0 ;
19534 int res1 = 0 ;
19535 int val2 ;
19536 int ecode2 = 0 ;
19537 PyObject * obj0 = 0 ;
19538 PyObject * obj1 = 0 ;
19539 char * kwnames[] = {
19540 (char *) "self",(char *) "depth", NULL
19541 };
19542
19543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19545 if (!SWIG_IsOK(res1)) {
19546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19547 }
19548 arg1 = reinterpret_cast< wxImage * >(argp1);
19549 if (obj1) {
19550 ecode2 = SWIG_AsVal_int(obj1, &val2);
19551 if (!SWIG_IsOK(ecode2)) {
19552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19553 }
19554 arg2 = static_cast< int >(val2);
19555 }
19556 {
19557 if (!wxPyCheckForApp()) SWIG_fail;
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = wxImage_ConvertToBitmap(arg1,arg2);
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19564 return resultobj;
19565 fail:
19566 return NULL;
19567 }
19568
19569
19570 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19571 PyObject *resultobj = 0;
19572 wxImage *arg1 = (wxImage *) 0 ;
19573 byte arg2 ;
19574 byte arg3 ;
19575 byte arg4 ;
19576 wxBitmap result;
19577 void *argp1 = 0 ;
19578 int res1 = 0 ;
19579 unsigned char val2 ;
19580 int ecode2 = 0 ;
19581 unsigned char val3 ;
19582 int ecode3 = 0 ;
19583 unsigned char val4 ;
19584 int ecode4 = 0 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 PyObject * obj2 = 0 ;
19588 PyObject * obj3 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19597 }
19598 arg1 = reinterpret_cast< wxImage * >(argp1);
19599 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19600 if (!SWIG_IsOK(ecode2)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19602 }
19603 arg2 = static_cast< byte >(val2);
19604 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19605 if (!SWIG_IsOK(ecode3)) {
19606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19607 }
19608 arg3 = static_cast< byte >(val3);
19609 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19610 if (!SWIG_IsOK(ecode4)) {
19611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19612 }
19613 arg4 = static_cast< byte >(val4);
19614 {
19615 if (!wxPyCheckForApp()) SWIG_fail;
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj = 0;
19630 wxImage *arg1 = (wxImage *) 0 ;
19631 double arg2 ;
19632 void *argp1 = 0 ;
19633 int res1 = 0 ;
19634 double val2 ;
19635 int ecode2 = 0 ;
19636 PyObject * obj0 = 0 ;
19637 PyObject * obj1 = 0 ;
19638 char * kwnames[] = {
19639 (char *) "self",(char *) "angle", NULL
19640 };
19641
19642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19644 if (!SWIG_IsOK(res1)) {
19645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19646 }
19647 arg1 = reinterpret_cast< wxImage * >(argp1);
19648 ecode2 = SWIG_AsVal_double(obj1, &val2);
19649 if (!SWIG_IsOK(ecode2)) {
19650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19651 }
19652 arg2 = static_cast< double >(val2);
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 (arg1)->RotateHue(arg2);
19656 wxPyEndAllowThreads(__tstate);
19657 if (PyErr_Occurred()) SWIG_fail;
19658 }
19659 resultobj = SWIG_Py_Void();
19660 return resultobj;
19661 fail:
19662 return NULL;
19663 }
19664
19665
19666 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj = 0;
19668 wxImage_RGBValue arg1 ;
19669 wxImage_HSVValue result;
19670 void *argp1 ;
19671 int res1 = 0 ;
19672 PyObject * obj0 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "rgb", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19678 {
19679 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19680 if (!SWIG_IsOK(res1)) {
19681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19682 }
19683 if (!argp1) {
19684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19685 } else {
19686 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19687 arg1 = *temp;
19688 if (SWIG_IsNewObj(res1)) delete temp;
19689 }
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = wxImage::RGBtoHSV(arg1);
19694 wxPyEndAllowThreads(__tstate);
19695 if (PyErr_Occurred()) SWIG_fail;
19696 }
19697 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19698 return resultobj;
19699 fail:
19700 return NULL;
19701 }
19702
19703
19704 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj = 0;
19706 wxImage_HSVValue arg1 ;
19707 wxImage_RGBValue result;
19708 void *argp1 ;
19709 int res1 = 0 ;
19710 PyObject * obj0 = 0 ;
19711 char * kwnames[] = {
19712 (char *) "hsv", NULL
19713 };
19714
19715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19716 {
19717 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19718 if (!SWIG_IsOK(res1)) {
19719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19720 }
19721 if (!argp1) {
19722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19723 } else {
19724 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19725 arg1 = *temp;
19726 if (SWIG_IsNewObj(res1)) delete temp;
19727 }
19728 }
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = wxImage::HSVtoRGB(arg1);
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19743 PyObject *obj;
19744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19745 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19746 return SWIG_Py_Void();
19747 }
19748
19749 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19750 return SWIG_Python_InitShadowInstance(args);
19751 }
19752
19753 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj = 0;
19755 int arg1 ;
19756 int arg2 ;
19757 buffer arg3 ;
19758 int arg4 ;
19759 buffer arg5 = (buffer) NULL ;
19760 int arg6 = (int) 0 ;
19761 wxImage *result = 0 ;
19762 int val1 ;
19763 int ecode1 = 0 ;
19764 int val2 ;
19765 int ecode2 = 0 ;
19766 Py_ssize_t temp3 ;
19767 Py_ssize_t temp5 ;
19768 PyObject * obj0 = 0 ;
19769 PyObject * obj1 = 0 ;
19770 PyObject * obj2 = 0 ;
19771 PyObject * obj3 = 0 ;
19772 char * kwnames[] = {
19773 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19774 };
19775
19776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19777 ecode1 = SWIG_AsVal_int(obj0, &val1);
19778 if (!SWIG_IsOK(ecode1)) {
19779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19780 }
19781 arg1 = static_cast< int >(val1);
19782 ecode2 = SWIG_AsVal_int(obj1, &val2);
19783 if (!SWIG_IsOK(ecode2)) {
19784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19785 }
19786 arg2 = static_cast< int >(val2);
19787 {
19788 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19789 arg4 = (int)temp3;
19790 }
19791 if (obj3) {
19792 {
19793 if (obj3 != Py_None) {
19794 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19795 arg6 = (int)temp5;
19796 }
19797 }
19798 }
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN int NullImage_set(PyObject *) {
19815 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19816 return 1;
19817 }
19818
19819
19820 SWIGINTERN PyObject *NullImage_get(void) {
19821 PyObject *pyobj = 0;
19822
19823 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19824 return pyobj;
19825 }
19826
19827
19828 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19829 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19830 return 1;
19831 }
19832
19833
19834 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19835 PyObject *pyobj = 0;
19836
19837 {
19838 #if wxUSE_UNICODE
19839 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19840 #else
19841 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19842 #endif
19843 }
19844 return pyobj;
19845 }
19846
19847
19848 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19849 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19850 return 1;
19851 }
19852
19853
19854 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19855 PyObject *pyobj = 0;
19856
19857 {
19858 #if wxUSE_UNICODE
19859 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19860 #else
19861 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19862 #endif
19863 }
19864 return pyobj;
19865 }
19866
19867
19868 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19869 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19870 return 1;
19871 }
19872
19873
19874 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19875 PyObject *pyobj = 0;
19876
19877 {
19878 #if wxUSE_UNICODE
19879 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19880 #else
19881 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19882 #endif
19883 }
19884 return pyobj;
19885 }
19886
19887
19888 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19889 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19890 return 1;
19891 }
19892
19893
19894 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19895 PyObject *pyobj = 0;
19896
19897 {
19898 #if wxUSE_UNICODE
19899 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19900 #else
19901 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19902 #endif
19903 }
19904 return pyobj;
19905 }
19906
19907
19908 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19909 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19910 return 1;
19911 }
19912
19913
19914 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19915 PyObject *pyobj = 0;
19916
19917 {
19918 #if wxUSE_UNICODE
19919 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19920 #else
19921 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19922 #endif
19923 }
19924 return pyobj;
19925 }
19926
19927
19928 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19929 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19930 return 1;
19931 }
19932
19933
19934 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19935 PyObject *pyobj = 0;
19936
19937 {
19938 #if wxUSE_UNICODE
19939 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19940 #else
19941 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19942 #endif
19943 }
19944 return pyobj;
19945 }
19946
19947
19948 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19949 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19950 return 1;
19951 }
19952
19953
19954 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19955 PyObject *pyobj = 0;
19956
19957 {
19958 #if wxUSE_UNICODE
19959 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19960 #else
19961 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19962 #endif
19963 }
19964 return pyobj;
19965 }
19966
19967
19968 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19969 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19970 return 1;
19971 }
19972
19973
19974 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19975 PyObject *pyobj = 0;
19976
19977 {
19978 #if wxUSE_UNICODE
19979 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19980 #else
19981 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19982 #endif
19983 }
19984 return pyobj;
19985 }
19986
19987
19988 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19989 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19990 return 1;
19991 }
19992
19993
19994 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19995 PyObject *pyobj = 0;
19996
19997 {
19998 #if wxUSE_UNICODE
19999 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20000 #else
20001 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20002 #endif
20003 }
20004 return pyobj;
20005 }
20006
20007
20008 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20009 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20010 return 1;
20011 }
20012
20013
20014 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20015 PyObject *pyobj = 0;
20016
20017 {
20018 #if wxUSE_UNICODE
20019 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20020 #else
20021 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20022 #endif
20023 }
20024 return pyobj;
20025 }
20026
20027
20028 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20029 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20030 return 1;
20031 }
20032
20033
20034 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20035 PyObject *pyobj = 0;
20036
20037 {
20038 #if wxUSE_UNICODE
20039 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20040 #else
20041 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20042 #endif
20043 }
20044 return pyobj;
20045 }
20046
20047
20048 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20049 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20050 return 1;
20051 }
20052
20053
20054 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20055 PyObject *pyobj = 0;
20056
20057 {
20058 #if wxUSE_UNICODE
20059 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20060 #else
20061 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20062 #endif
20063 }
20064 return pyobj;
20065 }
20066
20067
20068 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20069 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20070 return 1;
20071 }
20072
20073
20074 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20075 PyObject *pyobj = 0;
20076
20077 {
20078 #if wxUSE_UNICODE
20079 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20080 #else
20081 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20082 #endif
20083 }
20084 return pyobj;
20085 }
20086
20087
20088 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20089 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20090 return 1;
20091 }
20092
20093
20094 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20095 PyObject *pyobj = 0;
20096
20097 {
20098 #if wxUSE_UNICODE
20099 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20100 #else
20101 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20102 #endif
20103 }
20104 return pyobj;
20105 }
20106
20107
20108 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20109 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20110 return 1;
20111 }
20112
20113
20114 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20115 PyObject *pyobj = 0;
20116
20117 {
20118 #if wxUSE_UNICODE
20119 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20120 #else
20121 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20122 #endif
20123 }
20124 return pyobj;
20125 }
20126
20127
20128 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20129 PyObject *resultobj = 0;
20130 wxBMPHandler *result = 0 ;
20131
20132 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (wxBMPHandler *)new wxBMPHandler();
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *obj;
20148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20149 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20150 return SWIG_Py_Void();
20151 }
20152
20153 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 return SWIG_Python_InitShadowInstance(args);
20155 }
20156
20157 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *resultobj = 0;
20159 wxICOHandler *result = 0 ;
20160
20161 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (wxICOHandler *)new wxICOHandler();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *obj;
20177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20178 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20179 return SWIG_Py_Void();
20180 }
20181
20182 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 return SWIG_Python_InitShadowInstance(args);
20184 }
20185
20186 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxCURHandler *result = 0 ;
20189
20190 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (wxCURHandler *)new wxCURHandler();
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *obj;
20206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20207 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20208 return SWIG_Py_Void();
20209 }
20210
20211 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20212 return SWIG_Python_InitShadowInstance(args);
20213 }
20214
20215 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20216 PyObject *resultobj = 0;
20217 wxANIHandler *result = 0 ;
20218
20219 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (wxANIHandler *)new wxANIHandler();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20234 PyObject *obj;
20235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20236 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20237 return SWIG_Py_Void();
20238 }
20239
20240 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20241 return SWIG_Python_InitShadowInstance(args);
20242 }
20243
20244 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20245 PyObject *resultobj = 0;
20246 wxPNGHandler *result = 0 ;
20247
20248 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (wxPNGHandler *)new wxPNGHandler();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20263 PyObject *obj;
20264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20265 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20266 return SWIG_Py_Void();
20267 }
20268
20269 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 return SWIG_Python_InitShadowInstance(args);
20271 }
20272
20273 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *resultobj = 0;
20275 wxGIFHandler *result = 0 ;
20276
20277 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (wxGIFHandler *)new wxGIFHandler();
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20285 return resultobj;
20286 fail:
20287 return NULL;
20288 }
20289
20290
20291 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292 PyObject *obj;
20293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20294 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20295 return SWIG_Py_Void();
20296 }
20297
20298 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20299 return SWIG_Python_InitShadowInstance(args);
20300 }
20301
20302 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *resultobj = 0;
20304 wxPCXHandler *result = 0 ;
20305
20306 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 result = (wxPCXHandler *)new wxPCXHandler();
20310 wxPyEndAllowThreads(__tstate);
20311 if (PyErr_Occurred()) SWIG_fail;
20312 }
20313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *obj;
20322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20323 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20324 return SWIG_Py_Void();
20325 }
20326
20327 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 return SWIG_Python_InitShadowInstance(args);
20329 }
20330
20331 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *resultobj = 0;
20333 wxJPEGHandler *result = 0 ;
20334
20335 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (wxJPEGHandler *)new wxJPEGHandler();
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20343 return resultobj;
20344 fail:
20345 return NULL;
20346 }
20347
20348
20349 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20350 PyObject *obj;
20351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20352 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20353 return SWIG_Py_Void();
20354 }
20355
20356 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 return SWIG_Python_InitShadowInstance(args);
20358 }
20359
20360 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20361 PyObject *resultobj = 0;
20362 wxPNMHandler *result = 0 ;
20363
20364 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (wxPNMHandler *)new wxPNMHandler();
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20372 return resultobj;
20373 fail:
20374 return NULL;
20375 }
20376
20377
20378 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20379 PyObject *obj;
20380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20381 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20382 return SWIG_Py_Void();
20383 }
20384
20385 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 return SWIG_Python_InitShadowInstance(args);
20387 }
20388
20389 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxXPMHandler *result = 0 ;
20392
20393 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 result = (wxXPMHandler *)new wxXPMHandler();
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20408 PyObject *obj;
20409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20410 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20411 return SWIG_Py_Void();
20412 }
20413
20414 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 return SWIG_Python_InitShadowInstance(args);
20416 }
20417
20418 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20419 PyObject *resultobj = 0;
20420 wxTIFFHandler *result = 0 ;
20421
20422 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20423 {
20424 PyThreadState* __tstate = wxPyBeginAllowThreads();
20425 result = (wxTIFFHandler *)new wxTIFFHandler();
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20437 PyObject *obj;
20438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20439 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20440 return SWIG_Py_Void();
20441 }
20442
20443 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20444 return SWIG_Python_InitShadowInstance(args);
20445 }
20446
20447 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *resultobj = 0;
20449 wxTGAHandler *result = 0 ;
20450
20451 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (wxTGAHandler *)new wxTGAHandler();
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20459 return resultobj;
20460 fail:
20461 return NULL;
20462 }
20463
20464
20465 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 PyObject *obj;
20467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20468 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20469 return SWIG_Py_Void();
20470 }
20471
20472 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20473 return SWIG_Python_InitShadowInstance(args);
20474 }
20475
20476 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj = 0;
20478 wxImage *arg1 = 0 ;
20479 wxImage *arg2 = 0 ;
20480 int arg3 = (int) 236 ;
20481 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 void *argp2 = 0 ;
20486 int res2 = 0 ;
20487 int val3 ;
20488 int ecode3 = 0 ;
20489 int val4 ;
20490 int ecode4 = 0 ;
20491 PyObject * obj0 = 0 ;
20492 PyObject * obj1 = 0 ;
20493 PyObject * obj2 = 0 ;
20494 PyObject * obj3 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20503 }
20504 if (!argp1) {
20505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20506 }
20507 arg1 = reinterpret_cast< wxImage * >(argp1);
20508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20509 if (!SWIG_IsOK(res2)) {
20510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20511 }
20512 if (!argp2) {
20513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20514 }
20515 arg2 = reinterpret_cast< wxImage * >(argp2);
20516 if (obj2) {
20517 ecode3 = SWIG_AsVal_int(obj2, &val3);
20518 if (!SWIG_IsOK(ecode3)) {
20519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20520 }
20521 arg3 = static_cast< int >(val3);
20522 }
20523 if (obj3) {
20524 ecode4 = SWIG_AsVal_int(obj3, &val4);
20525 if (!SWIG_IsOK(ecode4)) {
20526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20527 }
20528 arg4 = static_cast< int >(val4);
20529 }
20530 {
20531 PyThreadState* __tstate = wxPyBeginAllowThreads();
20532 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 {
20537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20538 }
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20546 PyObject *obj;
20547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20548 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20549 return SWIG_Py_Void();
20550 }
20551
20552 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxEvtHandler *result = 0 ;
20555
20556 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (wxEvtHandler *)new wxEvtHandler();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20564 return resultobj;
20565 fail:
20566 return NULL;
20567 }
20568
20569
20570 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20571 PyObject *resultobj = 0;
20572 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20573 wxEvtHandler *result = 0 ;
20574 void *argp1 = 0 ;
20575 int res1 = 0 ;
20576 PyObject *swig_obj[1] ;
20577
20578 if (!args) SWIG_fail;
20579 swig_obj[0] = args;
20580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20581 if (!SWIG_IsOK(res1)) {
20582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20583 }
20584 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 {
20592 resultobj = wxPyMake_wxObject(result, 0);
20593 }
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *resultobj = 0;
20602 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20603 wxEvtHandler *result = 0 ;
20604 void *argp1 = 0 ;
20605 int res1 = 0 ;
20606 PyObject *swig_obj[1] ;
20607
20608 if (!args) SWIG_fail;
20609 swig_obj[0] = args;
20610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20611 if (!SWIG_IsOK(res1)) {
20612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20613 }
20614 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20618 wxPyEndAllowThreads(__tstate);
20619 if (PyErr_Occurred()) SWIG_fail;
20620 }
20621 {
20622 resultobj = wxPyMake_wxObject(result, 0);
20623 }
20624 return resultobj;
20625 fail:
20626 return NULL;
20627 }
20628
20629
20630 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20631 PyObject *resultobj = 0;
20632 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20633 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20634 void *argp1 = 0 ;
20635 int res1 = 0 ;
20636 void *argp2 = 0 ;
20637 int res2 = 0 ;
20638 PyObject * obj0 = 0 ;
20639 PyObject * obj1 = 0 ;
20640 char * kwnames[] = {
20641 (char *) "self",(char *) "handler", NULL
20642 };
20643
20644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20646 if (!SWIG_IsOK(res1)) {
20647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20648 }
20649 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20651 if (!SWIG_IsOK(res2)) {
20652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20653 }
20654 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 (arg1)->SetNextHandler(arg2);
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 resultobj = SWIG_Py_Void();
20662 return resultobj;
20663 fail:
20664 return NULL;
20665 }
20666
20667
20668 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj = 0;
20670 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20671 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20672 void *argp1 = 0 ;
20673 int res1 = 0 ;
20674 void *argp2 = 0 ;
20675 int res2 = 0 ;
20676 PyObject * obj0 = 0 ;
20677 PyObject * obj1 = 0 ;
20678 char * kwnames[] = {
20679 (char *) "self",(char *) "handler", NULL
20680 };
20681
20682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20686 }
20687 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20689 if (!SWIG_IsOK(res2)) {
20690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20691 }
20692 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20693 {
20694 PyThreadState* __tstate = wxPyBeginAllowThreads();
20695 (arg1)->SetPreviousHandler(arg2);
20696 wxPyEndAllowThreads(__tstate);
20697 if (PyErr_Occurred()) SWIG_fail;
20698 }
20699 resultobj = SWIG_Py_Void();
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20707 PyObject *resultobj = 0;
20708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20709 bool result;
20710 void *argp1 = 0 ;
20711 int res1 = 0 ;
20712 PyObject *swig_obj[1] ;
20713
20714 if (!args) SWIG_fail;
20715 swig_obj[0] = args;
20716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20717 if (!SWIG_IsOK(res1)) {
20718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20719 }
20720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 result = (bool)(arg1)->GetEvtHandlerEnabled();
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 {
20728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20729 }
20730 return resultobj;
20731 fail:
20732 return NULL;
20733 }
20734
20735
20736 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20737 PyObject *resultobj = 0;
20738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20739 bool arg2 ;
20740 void *argp1 = 0 ;
20741 int res1 = 0 ;
20742 bool val2 ;
20743 int ecode2 = 0 ;
20744 PyObject * obj0 = 0 ;
20745 PyObject * obj1 = 0 ;
20746 char * kwnames[] = {
20747 (char *) "self",(char *) "enabled", NULL
20748 };
20749
20750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20752 if (!SWIG_IsOK(res1)) {
20753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20754 }
20755 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20757 if (!SWIG_IsOK(ecode2)) {
20758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20759 }
20760 arg2 = static_cast< bool >(val2);
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 (arg1)->SetEvtHandlerEnabled(arg2);
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 resultobj = SWIG_Py_Void();
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20775 PyObject *resultobj = 0;
20776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20777 wxEvent *arg2 = 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 void *argp2 = 0 ;
20782 int res2 = 0 ;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 char * kwnames[] = {
20786 (char *) "self",(char *) "event", NULL
20787 };
20788
20789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20791 if (!SWIG_IsOK(res1)) {
20792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20793 }
20794 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20796 if (!SWIG_IsOK(res2)) {
20797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20798 }
20799 if (!argp2) {
20800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20801 }
20802 arg2 = reinterpret_cast< wxEvent * >(argp2);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 result = (bool)(arg1)->ProcessEvent(*arg2);
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 {
20810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20811 }
20812 return resultobj;
20813 fail:
20814 return NULL;
20815 }
20816
20817
20818 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj = 0;
20820 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20821 wxEvent *arg2 = 0 ;
20822 void *argp1 = 0 ;
20823 int res1 = 0 ;
20824 void *argp2 = 0 ;
20825 int res2 = 0 ;
20826 PyObject * obj0 = 0 ;
20827 PyObject * obj1 = 0 ;
20828 char * kwnames[] = {
20829 (char *) "self",(char *) "event", NULL
20830 };
20831
20832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20836 }
20837 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20839 if (!SWIG_IsOK(res2)) {
20840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20841 }
20842 if (!argp2) {
20843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20844 }
20845 arg2 = reinterpret_cast< wxEvent * >(argp2);
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 (arg1)->AddPendingEvent(*arg2);
20849 wxPyEndAllowThreads(__tstate);
20850 if (PyErr_Occurred()) SWIG_fail;
20851 }
20852 resultobj = SWIG_Py_Void();
20853 return resultobj;
20854 fail:
20855 return NULL;
20856 }
20857
20858
20859 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20860 PyObject *resultobj = 0;
20861 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 PyObject *swig_obj[1] ;
20865
20866 if (!args) SWIG_fail;
20867 swig_obj[0] = args;
20868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20871 }
20872 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 (arg1)->ProcessPendingEvents();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_Py_Void();
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj = 0;
20888 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20889 int arg2 ;
20890 int arg3 ;
20891 int arg4 ;
20892 PyObject *arg5 = (PyObject *) 0 ;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 int val2 ;
20896 int ecode2 = 0 ;
20897 int val3 ;
20898 int ecode3 = 0 ;
20899 int val4 ;
20900 int ecode4 = 0 ;
20901 PyObject * obj0 = 0 ;
20902 PyObject * obj1 = 0 ;
20903 PyObject * obj2 = 0 ;
20904 PyObject * obj3 = 0 ;
20905 PyObject * obj4 = 0 ;
20906 char * kwnames[] = {
20907 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20908 };
20909
20910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20914 }
20915 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20916 ecode2 = SWIG_AsVal_int(obj1, &val2);
20917 if (!SWIG_IsOK(ecode2)) {
20918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20919 }
20920 arg2 = static_cast< int >(val2);
20921 ecode3 = SWIG_AsVal_int(obj2, &val3);
20922 if (!SWIG_IsOK(ecode3)) {
20923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20924 }
20925 arg3 = static_cast< int >(val3);
20926 ecode4 = SWIG_AsVal_int(obj3, &val4);
20927 if (!SWIG_IsOK(ecode4)) {
20928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20929 }
20930 arg4 = static_cast< int >(val4);
20931 arg5 = obj4;
20932 {
20933 PyThreadState* __tstate = wxPyBeginAllowThreads();
20934 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 resultobj = SWIG_Py_Void();
20939 return resultobj;
20940 fail:
20941 return NULL;
20942 }
20943
20944
20945 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20946 PyObject *resultobj = 0;
20947 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20948 int arg2 ;
20949 int arg3 = (int) -1 ;
20950 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20951 bool result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 int val2 ;
20955 int ecode2 = 0 ;
20956 int val3 ;
20957 int ecode3 = 0 ;
20958 int val4 ;
20959 int ecode4 = 0 ;
20960 PyObject * obj0 = 0 ;
20961 PyObject * obj1 = 0 ;
20962 PyObject * obj2 = 0 ;
20963 PyObject * obj3 = 0 ;
20964 char * kwnames[] = {
20965 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20966 };
20967
20968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20970 if (!SWIG_IsOK(res1)) {
20971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20972 }
20973 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20974 ecode2 = SWIG_AsVal_int(obj1, &val2);
20975 if (!SWIG_IsOK(ecode2)) {
20976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20977 }
20978 arg2 = static_cast< int >(val2);
20979 if (obj2) {
20980 ecode3 = SWIG_AsVal_int(obj2, &val3);
20981 if (!SWIG_IsOK(ecode3)) {
20982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20983 }
20984 arg3 = static_cast< int >(val3);
20985 }
20986 if (obj3) {
20987 ecode4 = SWIG_AsVal_int(obj3, &val4);
20988 if (!SWIG_IsOK(ecode4)) {
20989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20990 }
20991 arg4 = static_cast< wxEventType >(val4);
20992 }
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 {
21000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21001 }
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21009 PyObject *resultobj = 0;
21010 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21011 PyObject *arg2 = (PyObject *) 0 ;
21012 bool arg3 = (bool) true ;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 bool val3 ;
21016 int ecode3 = 0 ;
21017 PyObject * obj0 = 0 ;
21018 PyObject * obj1 = 0 ;
21019 PyObject * obj2 = 0 ;
21020 char * kwnames[] = {
21021 (char *) "self",(char *) "_self",(char *) "incref", NULL
21022 };
21023
21024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21028 }
21029 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21030 arg2 = obj1;
21031 if (obj2) {
21032 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21033 if (!SWIG_IsOK(ecode3)) {
21034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21035 }
21036 arg3 = static_cast< bool >(val3);
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21041 wxPyEndAllowThreads(__tstate);
21042 if (PyErr_Occurred()) SWIG_fail;
21043 }
21044 resultobj = SWIG_Py_Void();
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21052 PyObject *obj;
21053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21054 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21055 return SWIG_Py_Void();
21056 }
21057
21058 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 return SWIG_Python_InitShadowInstance(args);
21060 }
21061
21062 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxEventType result;
21065
21066 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (wxEventType)wxNewEventType();
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 resultobj = SWIG_From_int(static_cast< int >(result));
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21081 PyObject *resultobj = 0;
21082 wxEvent *arg1 = (wxEvent *) 0 ;
21083 void *argp1 = 0 ;
21084 int res1 = 0 ;
21085 PyObject *swig_obj[1] ;
21086
21087 if (!args) SWIG_fail;
21088 swig_obj[0] = args;
21089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21090 if (!SWIG_IsOK(res1)) {
21091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21092 }
21093 arg1 = reinterpret_cast< wxEvent * >(argp1);
21094 {
21095 PyThreadState* __tstate = wxPyBeginAllowThreads();
21096 delete arg1;
21097
21098 wxPyEndAllowThreads(__tstate);
21099 if (PyErr_Occurred()) SWIG_fail;
21100 }
21101 resultobj = SWIG_Py_Void();
21102 return resultobj;
21103 fail:
21104 return NULL;
21105 }
21106
21107
21108 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21109 PyObject *resultobj = 0;
21110 wxEvent *arg1 = (wxEvent *) 0 ;
21111 wxEventType arg2 ;
21112 void *argp1 = 0 ;
21113 int res1 = 0 ;
21114 int val2 ;
21115 int ecode2 = 0 ;
21116 PyObject * obj0 = 0 ;
21117 PyObject * obj1 = 0 ;
21118 char * kwnames[] = {
21119 (char *) "self",(char *) "typ", NULL
21120 };
21121
21122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21124 if (!SWIG_IsOK(res1)) {
21125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21126 }
21127 arg1 = reinterpret_cast< wxEvent * >(argp1);
21128 ecode2 = SWIG_AsVal_int(obj1, &val2);
21129 if (!SWIG_IsOK(ecode2)) {
21130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21131 }
21132 arg2 = static_cast< wxEventType >(val2);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 (arg1)->SetEventType(arg2);
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = SWIG_Py_Void();
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxEvent *arg1 = (wxEvent *) 0 ;
21149 wxEventType result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxEvent * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 resultobj = SWIG_From_int(static_cast< int >(result));
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxEvent *arg1 = (wxEvent *) 0 ;
21177 wxObject *result = 0 ;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21187 }
21188 arg1 = reinterpret_cast< wxEvent * >(argp1);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 {
21196 resultobj = wxPyMake_wxObject(result, (bool)0);
21197 }
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj = 0;
21206 wxEvent *arg1 = (wxEvent *) 0 ;
21207 wxObject *arg2 = (wxObject *) 0 ;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 void *argp2 = 0 ;
21211 int res2 = 0 ;
21212 PyObject * obj0 = 0 ;
21213 PyObject * obj1 = 0 ;
21214 char * kwnames[] = {
21215 (char *) "self",(char *) "obj", NULL
21216 };
21217
21218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21222 }
21223 arg1 = reinterpret_cast< wxEvent * >(argp1);
21224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21225 if (!SWIG_IsOK(res2)) {
21226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21227 }
21228 arg2 = reinterpret_cast< wxObject * >(argp2);
21229 {
21230 PyThreadState* __tstate = wxPyBeginAllowThreads();
21231 (arg1)->SetEventObject(arg2);
21232 wxPyEndAllowThreads(__tstate);
21233 if (PyErr_Occurred()) SWIG_fail;
21234 }
21235 resultobj = SWIG_Py_Void();
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxEvent *arg1 = (wxEvent *) 0 ;
21245 long result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxEvent * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 resultobj = SWIG_From_long(static_cast< long >(result));
21264 return resultobj;
21265 fail:
21266 return NULL;
21267 }
21268
21269
21270 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21271 PyObject *resultobj = 0;
21272 wxEvent *arg1 = (wxEvent *) 0 ;
21273 long arg2 = (long) 0 ;
21274 void *argp1 = 0 ;
21275 int res1 = 0 ;
21276 long val2 ;
21277 int ecode2 = 0 ;
21278 PyObject * obj0 = 0 ;
21279 PyObject * obj1 = 0 ;
21280 char * kwnames[] = {
21281 (char *) "self",(char *) "ts", NULL
21282 };
21283
21284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21286 if (!SWIG_IsOK(res1)) {
21287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21288 }
21289 arg1 = reinterpret_cast< wxEvent * >(argp1);
21290 if (obj1) {
21291 ecode2 = SWIG_AsVal_long(obj1, &val2);
21292 if (!SWIG_IsOK(ecode2)) {
21293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21294 }
21295 arg2 = static_cast< long >(val2);
21296 }
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 (arg1)->SetTimestamp(arg2);
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 resultobj = SWIG_Py_Void();
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21311 PyObject *resultobj = 0;
21312 wxEvent *arg1 = (wxEvent *) 0 ;
21313 int result;
21314 void *argp1 = 0 ;
21315 int res1 = 0 ;
21316 PyObject *swig_obj[1] ;
21317
21318 if (!args) SWIG_fail;
21319 swig_obj[0] = args;
21320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21321 if (!SWIG_IsOK(res1)) {
21322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21323 }
21324 arg1 = reinterpret_cast< wxEvent * >(argp1);
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (int)((wxEvent const *)arg1)->GetId();
21328 wxPyEndAllowThreads(__tstate);
21329 if (PyErr_Occurred()) SWIG_fail;
21330 }
21331 resultobj = SWIG_From_int(static_cast< int >(result));
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21339 PyObject *resultobj = 0;
21340 wxEvent *arg1 = (wxEvent *) 0 ;
21341 int arg2 ;
21342 void *argp1 = 0 ;
21343 int res1 = 0 ;
21344 int val2 ;
21345 int ecode2 = 0 ;
21346 PyObject * obj0 = 0 ;
21347 PyObject * obj1 = 0 ;
21348 char * kwnames[] = {
21349 (char *) "self",(char *) "Id", NULL
21350 };
21351
21352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxEvent * >(argp1);
21358 ecode2 = SWIG_AsVal_int(obj1, &val2);
21359 if (!SWIG_IsOK(ecode2)) {
21360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21361 }
21362 arg2 = static_cast< int >(val2);
21363 {
21364 PyThreadState* __tstate = wxPyBeginAllowThreads();
21365 (arg1)->SetId(arg2);
21366 wxPyEndAllowThreads(__tstate);
21367 if (PyErr_Occurred()) SWIG_fail;
21368 }
21369 resultobj = SWIG_Py_Void();
21370 return resultobj;
21371 fail:
21372 return NULL;
21373 }
21374
21375
21376 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21377 PyObject *resultobj = 0;
21378 wxEvent *arg1 = (wxEvent *) 0 ;
21379 bool result;
21380 void *argp1 = 0 ;
21381 int res1 = 0 ;
21382 PyObject *swig_obj[1] ;
21383
21384 if (!args) SWIG_fail;
21385 swig_obj[0] = args;
21386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21389 }
21390 arg1 = reinterpret_cast< wxEvent * >(argp1);
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21394 wxPyEndAllowThreads(__tstate);
21395 if (PyErr_Occurred()) SWIG_fail;
21396 }
21397 {
21398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21399 }
21400 return resultobj;
21401 fail:
21402 return NULL;
21403 }
21404
21405
21406 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21407 PyObject *resultobj = 0;
21408 wxEvent *arg1 = (wxEvent *) 0 ;
21409 bool arg2 = (bool) true ;
21410 void *argp1 = 0 ;
21411 int res1 = 0 ;
21412 bool val2 ;
21413 int ecode2 = 0 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char * kwnames[] = {
21417 (char *) "self",(char *) "skip", NULL
21418 };
21419
21420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21422 if (!SWIG_IsOK(res1)) {
21423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21424 }
21425 arg1 = reinterpret_cast< wxEvent * >(argp1);
21426 if (obj1) {
21427 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21428 if (!SWIG_IsOK(ecode2)) {
21429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21430 }
21431 arg2 = static_cast< bool >(val2);
21432 }
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 (arg1)->Skip(arg2);
21436 wxPyEndAllowThreads(__tstate);
21437 if (PyErr_Occurred()) SWIG_fail;
21438 }
21439 resultobj = SWIG_Py_Void();
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxEvent *arg1 = (wxEvent *) 0 ;
21449 bool result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21459 }
21460 arg1 = reinterpret_cast< wxEvent * >(argp1);
21461 {
21462 PyThreadState* __tstate = wxPyBeginAllowThreads();
21463 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21464 wxPyEndAllowThreads(__tstate);
21465 if (PyErr_Occurred()) SWIG_fail;
21466 }
21467 {
21468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21469 }
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 PyObject *resultobj = 0;
21478 wxEvent *arg1 = (wxEvent *) 0 ;
21479 bool result;
21480 void *argp1 = 0 ;
21481 int res1 = 0 ;
21482 PyObject *swig_obj[1] ;
21483
21484 if (!args) SWIG_fail;
21485 swig_obj[0] = args;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21489 }
21490 arg1 = reinterpret_cast< wxEvent * >(argp1);
21491 {
21492 PyThreadState* __tstate = wxPyBeginAllowThreads();
21493 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21494 wxPyEndAllowThreads(__tstate);
21495 if (PyErr_Occurred()) SWIG_fail;
21496 }
21497 {
21498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21499 }
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21507 PyObject *resultobj = 0;
21508 wxEvent *arg1 = (wxEvent *) 0 ;
21509 int result;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 PyObject *swig_obj[1] ;
21513
21514 if (!args) SWIG_fail;
21515 swig_obj[0] = args;
21516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21517 if (!SWIG_IsOK(res1)) {
21518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21519 }
21520 arg1 = reinterpret_cast< wxEvent * >(argp1);
21521 {
21522 PyThreadState* __tstate = wxPyBeginAllowThreads();
21523 result = (int)(arg1)->StopPropagation();
21524 wxPyEndAllowThreads(__tstate);
21525 if (PyErr_Occurred()) SWIG_fail;
21526 }
21527 resultobj = SWIG_From_int(static_cast< int >(result));
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21535 PyObject *resultobj = 0;
21536 wxEvent *arg1 = (wxEvent *) 0 ;
21537 int arg2 ;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 int val2 ;
21541 int ecode2 = 0 ;
21542 PyObject * obj0 = 0 ;
21543 PyObject * obj1 = 0 ;
21544 char * kwnames[] = {
21545 (char *) "self",(char *) "propagationLevel", NULL
21546 };
21547
21548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21550 if (!SWIG_IsOK(res1)) {
21551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21552 }
21553 arg1 = reinterpret_cast< wxEvent * >(argp1);
21554 ecode2 = SWIG_AsVal_int(obj1, &val2);
21555 if (!SWIG_IsOK(ecode2)) {
21556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21557 }
21558 arg2 = static_cast< int >(val2);
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 (arg1)->ResumePropagation(arg2);
21562 wxPyEndAllowThreads(__tstate);
21563 if (PyErr_Occurred()) SWIG_fail;
21564 }
21565 resultobj = SWIG_Py_Void();
21566 return resultobj;
21567 fail:
21568 return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxEvent *arg1 = (wxEvent *) 0 ;
21575 wxEvent *result = 0 ;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 PyObject *swig_obj[1] ;
21579
21580 if (!args) SWIG_fail;
21581 swig_obj[0] = args;
21582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21583 if (!SWIG_IsOK(res1)) {
21584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21585 }
21586 arg1 = reinterpret_cast< wxEvent * >(argp1);
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (wxEvent *)(arg1)->Clone();
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21594 return resultobj;
21595 fail:
21596 return NULL;
21597 }
21598
21599
21600 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21601 PyObject *obj;
21602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21603 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21604 return SWIG_Py_Void();
21605 }
21606
21607 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21608 PyObject *resultobj = 0;
21609 wxEvent *arg1 = 0 ;
21610 wxPropagationDisabler *result = 0 ;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 PyObject * obj0 = 0 ;
21614 char * kwnames[] = {
21615 (char *) "event", NULL
21616 };
21617
21618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21619 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21620 if (!SWIG_IsOK(res1)) {
21621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21622 }
21623 if (!argp1) {
21624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21625 }
21626 arg1 = reinterpret_cast< wxEvent * >(argp1);
21627 {
21628 PyThreadState* __tstate = wxPyBeginAllowThreads();
21629 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21630 wxPyEndAllowThreads(__tstate);
21631 if (PyErr_Occurred()) SWIG_fail;
21632 }
21633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21634 return resultobj;
21635 fail:
21636 return NULL;
21637 }
21638
21639
21640 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 PyObject *resultobj = 0;
21642 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21643 void *argp1 = 0 ;
21644 int res1 = 0 ;
21645 PyObject *swig_obj[1] ;
21646
21647 if (!args) SWIG_fail;
21648 swig_obj[0] = args;
21649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21650 if (!SWIG_IsOK(res1)) {
21651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21652 }
21653 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21654 {
21655 PyThreadState* __tstate = wxPyBeginAllowThreads();
21656 delete arg1;
21657
21658 wxPyEndAllowThreads(__tstate);
21659 if (PyErr_Occurred()) SWIG_fail;
21660 }
21661 resultobj = SWIG_Py_Void();
21662 return resultobj;
21663 fail:
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *obj;
21670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21672 return SWIG_Py_Void();
21673 }
21674
21675 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21676 return SWIG_Python_InitShadowInstance(args);
21677 }
21678
21679 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj = 0;
21681 wxEvent *arg1 = 0 ;
21682 wxPropagateOnce *result = 0 ;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 PyObject * obj0 = 0 ;
21686 char * kwnames[] = {
21687 (char *) "event", NULL
21688 };
21689
21690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21691 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21692 if (!SWIG_IsOK(res1)) {
21693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21694 }
21695 if (!argp1) {
21696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21697 }
21698 arg1 = reinterpret_cast< wxEvent * >(argp1);
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21706 return resultobj;
21707 fail:
21708 return NULL;
21709 }
21710
21711
21712 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21713 PyObject *resultobj = 0;
21714 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21724 }
21725 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 delete arg1;
21729
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_Py_Void();
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 PyObject *obj;
21742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21744 return SWIG_Py_Void();
21745 }
21746
21747 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 return SWIG_Python_InitShadowInstance(args);
21749 }
21750
21751 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj = 0;
21753 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21754 int arg2 = (int) 0 ;
21755 wxCommandEvent *result = 0 ;
21756 int val1 ;
21757 int ecode1 = 0 ;
21758 int val2 ;
21759 int ecode2 = 0 ;
21760 PyObject * obj0 = 0 ;
21761 PyObject * obj1 = 0 ;
21762 char * kwnames[] = {
21763 (char *) "commandType",(char *) "winid", NULL
21764 };
21765
21766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21767 if (obj0) {
21768 ecode1 = SWIG_AsVal_int(obj0, &val1);
21769 if (!SWIG_IsOK(ecode1)) {
21770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21771 }
21772 arg1 = static_cast< wxEventType >(val1);
21773 }
21774 if (obj1) {
21775 ecode2 = SWIG_AsVal_int(obj1, &val2);
21776 if (!SWIG_IsOK(ecode2)) {
21777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21778 }
21779 arg2 = static_cast< int >(val2);
21780 }
21781 {
21782 PyThreadState* __tstate = wxPyBeginAllowThreads();
21783 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21807 }
21808 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 resultobj = SWIG_From_int(static_cast< int >(result));
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = 0;
21824 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21825 wxString *arg2 = 0 ;
21826 void *argp1 = 0 ;
21827 int res1 = 0 ;
21828 bool temp2 = false ;
21829 PyObject * obj0 = 0 ;
21830 PyObject * obj1 = 0 ;
21831 char * kwnames[] = {
21832 (char *) "self",(char *) "s", NULL
21833 };
21834
21835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21837 if (!SWIG_IsOK(res1)) {
21838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21839 }
21840 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21841 {
21842 arg2 = wxString_in_helper(obj1);
21843 if (arg2 == NULL) SWIG_fail;
21844 temp2 = true;
21845 }
21846 {
21847 PyThreadState* __tstate = wxPyBeginAllowThreads();
21848 (arg1)->SetString((wxString const &)*arg2);
21849 wxPyEndAllowThreads(__tstate);
21850 if (PyErr_Occurred()) SWIG_fail;
21851 }
21852 resultobj = SWIG_Py_Void();
21853 {
21854 if (temp2)
21855 delete arg2;
21856 }
21857 return resultobj;
21858 fail:
21859 {
21860 if (temp2)
21861 delete arg2;
21862 }
21863 return NULL;
21864 }
21865
21866
21867 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21868 PyObject *resultobj = 0;
21869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21870 wxString result;
21871 void *argp1 = 0 ;
21872 int res1 = 0 ;
21873 PyObject *swig_obj[1] ;
21874
21875 if (!args) SWIG_fail;
21876 swig_obj[0] = args;
21877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21878 if (!SWIG_IsOK(res1)) {
21879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21880 }
21881 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = ((wxCommandEvent const *)arg1)->GetString();
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889 #if wxUSE_UNICODE
21890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21891 #else
21892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21893 #endif
21894 }
21895 return resultobj;
21896 fail:
21897 return NULL;
21898 }
21899
21900
21901 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21902 PyObject *resultobj = 0;
21903 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21904 bool result;
21905 void *argp1 = 0 ;
21906 int res1 = 0 ;
21907 PyObject *swig_obj[1] ;
21908
21909 if (!args) SWIG_fail;
21910 swig_obj[0] = args;
21911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21912 if (!SWIG_IsOK(res1)) {
21913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21914 }
21915 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21916 {
21917 PyThreadState* __tstate = wxPyBeginAllowThreads();
21918 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 {
21923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21924 }
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21932 PyObject *resultobj = 0;
21933 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21934 bool result;
21935 void *argp1 = 0 ;
21936 int res1 = 0 ;
21937 PyObject *swig_obj[1] ;
21938
21939 if (!args) SWIG_fail;
21940 swig_obj[0] = args;
21941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21942 if (!SWIG_IsOK(res1)) {
21943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21944 }
21945 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 {
21953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21954 }
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj = 0;
21963 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21964 long arg2 ;
21965 void *argp1 = 0 ;
21966 int res1 = 0 ;
21967 long val2 ;
21968 int ecode2 = 0 ;
21969 PyObject * obj0 = 0 ;
21970 PyObject * obj1 = 0 ;
21971 char * kwnames[] = {
21972 (char *) "self",(char *) "extraLong", NULL
21973 };
21974
21975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21979 }
21980 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21981 ecode2 = SWIG_AsVal_long(obj1, &val2);
21982 if (!SWIG_IsOK(ecode2)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21984 }
21985 arg2 = static_cast< long >(val2);
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 (arg1)->SetExtraLong(arg2);
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 resultobj = SWIG_Py_Void();
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 PyObject *resultobj = 0;
22001 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22002 long result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 PyObject *swig_obj[1] ;
22006
22007 if (!args) SWIG_fail;
22008 swig_obj[0] = args;
22009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22010 if (!SWIG_IsOK(res1)) {
22011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22012 }
22013 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22014 {
22015 PyThreadState* __tstate = wxPyBeginAllowThreads();
22016 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_From_long(static_cast< long >(result));
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj = 0;
22029 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22030 int arg2 ;
22031 void *argp1 = 0 ;
22032 int res1 = 0 ;
22033 int val2 ;
22034 int ecode2 = 0 ;
22035 PyObject * obj0 = 0 ;
22036 PyObject * obj1 = 0 ;
22037 char * kwnames[] = {
22038 (char *) "self",(char *) "i", NULL
22039 };
22040
22041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22045 }
22046 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22047 ecode2 = SWIG_AsVal_int(obj1, &val2);
22048 if (!SWIG_IsOK(ecode2)) {
22049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22050 }
22051 arg2 = static_cast< int >(val2);
22052 {
22053 PyThreadState* __tstate = wxPyBeginAllowThreads();
22054 (arg1)->SetInt(arg2);
22055 wxPyEndAllowThreads(__tstate);
22056 if (PyErr_Occurred()) SWIG_fail;
22057 }
22058 resultobj = SWIG_Py_Void();
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22068 int result;
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22078 }
22079 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 resultobj = SWIG_From_int(static_cast< int >(result));
22087 return resultobj;
22088 fail:
22089 return NULL;
22090 }
22091
22092
22093 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22094 PyObject *resultobj = 0;
22095 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22096 PyObject *result = 0 ;
22097 void *argp1 = 0 ;
22098 int res1 = 0 ;
22099 PyObject *swig_obj[1] ;
22100
22101 if (!args) SWIG_fail;
22102 swig_obj[0] = args;
22103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22104 if (!SWIG_IsOK(res1)) {
22105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22106 }
22107 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = result;
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22122 PyObject *resultobj = 0;
22123 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22124 PyObject *arg2 = (PyObject *) 0 ;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 char * kwnames[] = {
22130 (char *) "self",(char *) "clientData", NULL
22131 };
22132
22133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22135 if (!SWIG_IsOK(res1)) {
22136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22137 }
22138 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22139 arg2 = obj1;
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 wxCommandEvent_SetClientData(arg1,arg2);
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 resultobj = SWIG_Py_Void();
22147 return resultobj;
22148 fail:
22149 return NULL;
22150 }
22151
22152
22153 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22154 PyObject *resultobj = 0;
22155 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22156 wxEvent *result = 0 ;
22157 void *argp1 = 0 ;
22158 int res1 = 0 ;
22159 PyObject *swig_obj[1] ;
22160
22161 if (!args) SWIG_fail;
22162 swig_obj[0] = args;
22163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22164 if (!SWIG_IsOK(res1)) {
22165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22166 }
22167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *obj;
22183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22184 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22185 return SWIG_Py_Void();
22186 }
22187
22188 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22189 return SWIG_Python_InitShadowInstance(args);
22190 }
22191
22192 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22195 int arg2 = (int) 0 ;
22196 wxNotifyEvent *result = 0 ;
22197 int val1 ;
22198 int ecode1 = 0 ;
22199 int val2 ;
22200 int ecode2 = 0 ;
22201 PyObject * obj0 = 0 ;
22202 PyObject * obj1 = 0 ;
22203 char * kwnames[] = {
22204 (char *) "commandType",(char *) "winid", NULL
22205 };
22206
22207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22208 if (obj0) {
22209 ecode1 = SWIG_AsVal_int(obj0, &val1);
22210 if (!SWIG_IsOK(ecode1)) {
22211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22212 }
22213 arg1 = static_cast< wxEventType >(val1);
22214 }
22215 if (obj1) {
22216 ecode2 = SWIG_AsVal_int(obj1, &val2);
22217 if (!SWIG_IsOK(ecode2)) {
22218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22219 }
22220 arg2 = static_cast< int >(val2);
22221 }
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22238 void *argp1 = 0 ;
22239 int res1 = 0 ;
22240 PyObject *swig_obj[1] ;
22241
22242 if (!args) SWIG_fail;
22243 swig_obj[0] = args;
22244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22245 if (!SWIG_IsOK(res1)) {
22246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22247 }
22248 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 (arg1)->Veto();
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_Py_Void();
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22263 PyObject *resultobj = 0;
22264 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22265 void *argp1 = 0 ;
22266 int res1 = 0 ;
22267 PyObject *swig_obj[1] ;
22268
22269 if (!args) SWIG_fail;
22270 swig_obj[0] = args;
22271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22272 if (!SWIG_IsOK(res1)) {
22273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22274 }
22275 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22276 {
22277 PyThreadState* __tstate = wxPyBeginAllowThreads();
22278 (arg1)->Allow();
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = SWIG_Py_Void();
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22290 PyObject *resultobj = 0;
22291 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22292 bool result;
22293 void *argp1 = 0 ;
22294 int res1 = 0 ;
22295 PyObject *swig_obj[1] ;
22296
22297 if (!args) SWIG_fail;
22298 swig_obj[0] = args;
22299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22300 if (!SWIG_IsOK(res1)) {
22301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22302 }
22303 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22304 {
22305 PyThreadState* __tstate = wxPyBeginAllowThreads();
22306 result = (bool)(arg1)->IsAllowed();
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 {
22311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22312 }
22313 return resultobj;
22314 fail:
22315 return NULL;
22316 }
22317
22318
22319 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22320 PyObject *obj;
22321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22322 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22323 return SWIG_Py_Void();
22324 }
22325
22326 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22327 return SWIG_Python_InitShadowInstance(args);
22328 }
22329
22330 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22331 PyObject *resultobj = 0;
22332 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22333 int arg2 = (int) 0 ;
22334 int arg3 = (int) 0 ;
22335 int arg4 = (int) 0 ;
22336 wxScrollEvent *result = 0 ;
22337 int val1 ;
22338 int ecode1 = 0 ;
22339 int val2 ;
22340 int ecode2 = 0 ;
22341 int val3 ;
22342 int ecode3 = 0 ;
22343 int val4 ;
22344 int ecode4 = 0 ;
22345 PyObject * obj0 = 0 ;
22346 PyObject * obj1 = 0 ;
22347 PyObject * obj2 = 0 ;
22348 PyObject * obj3 = 0 ;
22349 char * kwnames[] = {
22350 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22351 };
22352
22353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22354 if (obj0) {
22355 ecode1 = SWIG_AsVal_int(obj0, &val1);
22356 if (!SWIG_IsOK(ecode1)) {
22357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22358 }
22359 arg1 = static_cast< wxEventType >(val1);
22360 }
22361 if (obj1) {
22362 ecode2 = SWIG_AsVal_int(obj1, &val2);
22363 if (!SWIG_IsOK(ecode2)) {
22364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22365 }
22366 arg2 = static_cast< int >(val2);
22367 }
22368 if (obj2) {
22369 ecode3 = SWIG_AsVal_int(obj2, &val3);
22370 if (!SWIG_IsOK(ecode3)) {
22371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22372 }
22373 arg3 = static_cast< int >(val3);
22374 }
22375 if (obj3) {
22376 ecode4 = SWIG_AsVal_int(obj3, &val4);
22377 if (!SWIG_IsOK(ecode4)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22379 }
22380 arg4 = static_cast< int >(val4);
22381 }
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22385 wxPyEndAllowThreads(__tstate);
22386 if (PyErr_Occurred()) SWIG_fail;
22387 }
22388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22396 PyObject *resultobj = 0;
22397 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22398 int result;
22399 void *argp1 = 0 ;
22400 int res1 = 0 ;
22401 PyObject *swig_obj[1] ;
22402
22403 if (!args) SWIG_fail;
22404 swig_obj[0] = args;
22405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22406 if (!SWIG_IsOK(res1)) {
22407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22408 }
22409 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 resultobj = SWIG_From_int(static_cast< int >(result));
22417 return resultobj;
22418 fail:
22419 return NULL;
22420 }
22421
22422
22423 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22424 PyObject *resultobj = 0;
22425 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22426 int result;
22427 void *argp1 = 0 ;
22428 int res1 = 0 ;
22429 PyObject *swig_obj[1] ;
22430
22431 if (!args) SWIG_fail;
22432 swig_obj[0] = args;
22433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22434 if (!SWIG_IsOK(res1)) {
22435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22436 }
22437 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_From_int(static_cast< int >(result));
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22452 PyObject *resultobj = 0;
22453 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22454 int arg2 ;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 int val2 ;
22458 int ecode2 = 0 ;
22459 PyObject * obj0 = 0 ;
22460 PyObject * obj1 = 0 ;
22461 char * kwnames[] = {
22462 (char *) "self",(char *) "orient", NULL
22463 };
22464
22465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22467 if (!SWIG_IsOK(res1)) {
22468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22469 }
22470 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22471 ecode2 = SWIG_AsVal_int(obj1, &val2);
22472 if (!SWIG_IsOK(ecode2)) {
22473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22474 }
22475 arg2 = static_cast< int >(val2);
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 (arg1)->SetOrientation(arg2);
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 resultobj = SWIG_Py_Void();
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22490 PyObject *resultobj = 0;
22491 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22492 int arg2 ;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 int val2 ;
22496 int ecode2 = 0 ;
22497 PyObject * obj0 = 0 ;
22498 PyObject * obj1 = 0 ;
22499 char * kwnames[] = {
22500 (char *) "self",(char *) "pos", NULL
22501 };
22502
22503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22507 }
22508 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22509 ecode2 = SWIG_AsVal_int(obj1, &val2);
22510 if (!SWIG_IsOK(ecode2)) {
22511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22512 }
22513 arg2 = static_cast< int >(val2);
22514 {
22515 PyThreadState* __tstate = wxPyBeginAllowThreads();
22516 (arg1)->SetPosition(arg2);
22517 wxPyEndAllowThreads(__tstate);
22518 if (PyErr_Occurred()) SWIG_fail;
22519 }
22520 resultobj = SWIG_Py_Void();
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *obj;
22529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22530 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22531 return SWIG_Py_Void();
22532 }
22533
22534 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22535 return SWIG_Python_InitShadowInstance(args);
22536 }
22537
22538 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj = 0;
22540 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22541 int arg2 = (int) 0 ;
22542 int arg3 = (int) 0 ;
22543 wxScrollWinEvent *result = 0 ;
22544 int val1 ;
22545 int ecode1 = 0 ;
22546 int val2 ;
22547 int ecode2 = 0 ;
22548 int val3 ;
22549 int ecode3 = 0 ;
22550 PyObject * obj0 = 0 ;
22551 PyObject * obj1 = 0 ;
22552 PyObject * obj2 = 0 ;
22553 char * kwnames[] = {
22554 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22555 };
22556
22557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22558 if (obj0) {
22559 ecode1 = SWIG_AsVal_int(obj0, &val1);
22560 if (!SWIG_IsOK(ecode1)) {
22561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22562 }
22563 arg1 = static_cast< wxEventType >(val1);
22564 }
22565 if (obj1) {
22566 ecode2 = SWIG_AsVal_int(obj1, &val2);
22567 if (!SWIG_IsOK(ecode2)) {
22568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22569 }
22570 arg2 = static_cast< int >(val2);
22571 }
22572 if (obj2) {
22573 ecode3 = SWIG_AsVal_int(obj2, &val3);
22574 if (!SWIG_IsOK(ecode3)) {
22575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22576 }
22577 arg3 = static_cast< int >(val3);
22578 }
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 PyObject *resultobj = 0;
22594 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22595 int result;
22596 void *argp1 = 0 ;
22597 int res1 = 0 ;
22598 PyObject *swig_obj[1] ;
22599
22600 if (!args) SWIG_fail;
22601 swig_obj[0] = args;
22602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22605 }
22606 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_From_int(static_cast< int >(result));
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22621 PyObject *resultobj = 0;
22622 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22623 int result;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 PyObject *swig_obj[1] ;
22627
22628 if (!args) SWIG_fail;
22629 swig_obj[0] = args;
22630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22631 if (!SWIG_IsOK(res1)) {
22632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22633 }
22634 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22638 wxPyEndAllowThreads(__tstate);
22639 if (PyErr_Occurred()) SWIG_fail;
22640 }
22641 resultobj = SWIG_From_int(static_cast< int >(result));
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22649 PyObject *resultobj = 0;
22650 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22651 int arg2 ;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 int val2 ;
22655 int ecode2 = 0 ;
22656 PyObject * obj0 = 0 ;
22657 PyObject * obj1 = 0 ;
22658 char * kwnames[] = {
22659 (char *) "self",(char *) "orient", NULL
22660 };
22661
22662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22664 if (!SWIG_IsOK(res1)) {
22665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22666 }
22667 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22668 ecode2 = SWIG_AsVal_int(obj1, &val2);
22669 if (!SWIG_IsOK(ecode2)) {
22670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22671 }
22672 arg2 = static_cast< int >(val2);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 (arg1)->SetOrientation(arg2);
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_Py_Void();
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22687 PyObject *resultobj = 0;
22688 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22689 int arg2 ;
22690 void *argp1 = 0 ;
22691 int res1 = 0 ;
22692 int val2 ;
22693 int ecode2 = 0 ;
22694 PyObject * obj0 = 0 ;
22695 PyObject * obj1 = 0 ;
22696 char * kwnames[] = {
22697 (char *) "self",(char *) "pos", NULL
22698 };
22699
22700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22704 }
22705 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22706 ecode2 = SWIG_AsVal_int(obj1, &val2);
22707 if (!SWIG_IsOK(ecode2)) {
22708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22709 }
22710 arg2 = static_cast< int >(val2);
22711 {
22712 PyThreadState* __tstate = wxPyBeginAllowThreads();
22713 (arg1)->SetPosition(arg2);
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 resultobj = SWIG_Py_Void();
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *obj;
22726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22727 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22728 return SWIG_Py_Void();
22729 }
22730
22731 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 return SWIG_Python_InitShadowInstance(args);
22733 }
22734
22735 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj = 0;
22737 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22738 wxMouseEvent *result = 0 ;
22739 int val1 ;
22740 int ecode1 = 0 ;
22741 PyObject * obj0 = 0 ;
22742 char * kwnames[] = {
22743 (char *) "mouseType", NULL
22744 };
22745
22746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22747 if (obj0) {
22748 ecode1 = SWIG_AsVal_int(obj0, &val1);
22749 if (!SWIG_IsOK(ecode1)) {
22750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22751 }
22752 arg1 = static_cast< wxEventType >(val1);
22753 }
22754 {
22755 PyThreadState* __tstate = wxPyBeginAllowThreads();
22756 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22768 PyObject *resultobj = 0;
22769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22770 bool result;
22771 void *argp1 = 0 ;
22772 int res1 = 0 ;
22773 PyObject *swig_obj[1] ;
22774
22775 if (!args) SWIG_fail;
22776 swig_obj[0] = args;
22777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22778 if (!SWIG_IsOK(res1)) {
22779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22780 }
22781 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 {
22789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22790 }
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj = 0;
22799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22800 int arg2 = (int) wxMOUSE_BTN_ANY ;
22801 bool result;
22802 void *argp1 = 0 ;
22803 int res1 = 0 ;
22804 int val2 ;
22805 int ecode2 = 0 ;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808 char * kwnames[] = {
22809 (char *) "self",(char *) "but", NULL
22810 };
22811
22812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22814 if (!SWIG_IsOK(res1)) {
22815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22816 }
22817 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22818 if (obj1) {
22819 ecode2 = SWIG_AsVal_int(obj1, &val2);
22820 if (!SWIG_IsOK(ecode2)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22822 }
22823 arg2 = static_cast< int >(val2);
22824 }
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 {
22832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22833 }
22834 return resultobj;
22835 fail:
22836 return NULL;
22837 }
22838
22839
22840 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22841 PyObject *resultobj = 0;
22842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22843 int arg2 = (int) wxMOUSE_BTN_ANY ;
22844 bool result;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 int val2 ;
22848 int ecode2 = 0 ;
22849 PyObject * obj0 = 0 ;
22850 PyObject * obj1 = 0 ;
22851 char * kwnames[] = {
22852 (char *) "self",(char *) "but", NULL
22853 };
22854
22855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22859 }
22860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22861 if (obj1) {
22862 ecode2 = SWIG_AsVal_int(obj1, &val2);
22863 if (!SWIG_IsOK(ecode2)) {
22864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22865 }
22866 arg2 = static_cast< int >(val2);
22867 }
22868 {
22869 PyThreadState* __tstate = wxPyBeginAllowThreads();
22870 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22871 wxPyEndAllowThreads(__tstate);
22872 if (PyErr_Occurred()) SWIG_fail;
22873 }
22874 {
22875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22876 }
22877 return resultobj;
22878 fail:
22879 return NULL;
22880 }
22881
22882
22883 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22884 PyObject *resultobj = 0;
22885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22886 int arg2 = (int) wxMOUSE_BTN_ANY ;
22887 bool result;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 int val2 ;
22891 int ecode2 = 0 ;
22892 PyObject * obj0 = 0 ;
22893 PyObject * obj1 = 0 ;
22894 char * kwnames[] = {
22895 (char *) "self",(char *) "but", NULL
22896 };
22897
22898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22902 }
22903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22904 if (obj1) {
22905 ecode2 = SWIG_AsVal_int(obj1, &val2);
22906 if (!SWIG_IsOK(ecode2)) {
22907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22908 }
22909 arg2 = static_cast< int >(val2);
22910 }
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22914 wxPyEndAllowThreads(__tstate);
22915 if (PyErr_Occurred()) SWIG_fail;
22916 }
22917 {
22918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22919 }
22920 return resultobj;
22921 fail:
22922 return NULL;
22923 }
22924
22925
22926 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22927 PyObject *resultobj = 0;
22928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22929 int arg2 ;
22930 bool result;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 int val2 ;
22934 int ecode2 = 0 ;
22935 PyObject * obj0 = 0 ;
22936 PyObject * obj1 = 0 ;
22937 char * kwnames[] = {
22938 (char *) "self",(char *) "button", NULL
22939 };
22940
22941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22943 if (!SWIG_IsOK(res1)) {
22944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22945 }
22946 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22947 ecode2 = SWIG_AsVal_int(obj1, &val2);
22948 if (!SWIG_IsOK(ecode2)) {
22949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22950 }
22951 arg2 = static_cast< int >(val2);
22952 {
22953 PyThreadState* __tstate = wxPyBeginAllowThreads();
22954 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22955 wxPyEndAllowThreads(__tstate);
22956 if (PyErr_Occurred()) SWIG_fail;
22957 }
22958 {
22959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22960 }
22961 return resultobj;
22962 fail:
22963 return NULL;
22964 }
22965
22966
22967 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22968 PyObject *resultobj = 0;
22969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22970 int arg2 ;
22971 bool result;
22972 void *argp1 = 0 ;
22973 int res1 = 0 ;
22974 int val2 ;
22975 int ecode2 = 0 ;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978 char * kwnames[] = {
22979 (char *) "self",(char *) "but", NULL
22980 };
22981
22982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22986 }
22987 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22988 ecode2 = SWIG_AsVal_int(obj1, &val2);
22989 if (!SWIG_IsOK(ecode2)) {
22990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22991 }
22992 arg2 = static_cast< int >(val2);
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 {
23000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23001 }
23002 return resultobj;
23003 fail:
23004 return NULL;
23005 }
23006
23007
23008 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23009 PyObject *resultobj = 0;
23010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23011 int result;
23012 void *argp1 = 0 ;
23013 int res1 = 0 ;
23014 PyObject *swig_obj[1] ;
23015
23016 if (!args) SWIG_fail;
23017 swig_obj[0] = args;
23018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23019 if (!SWIG_IsOK(res1)) {
23020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23021 }
23022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 resultobj = SWIG_From_int(static_cast< int >(result));
23030 return resultobj;
23031 fail:
23032 return NULL;
23033 }
23034
23035
23036 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23037 PyObject *resultobj = 0;
23038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23039 bool result;
23040 void *argp1 = 0 ;
23041 int res1 = 0 ;
23042 PyObject *swig_obj[1] ;
23043
23044 if (!args) SWIG_fail;
23045 swig_obj[0] = args;
23046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23047 if (!SWIG_IsOK(res1)) {
23048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23049 }
23050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23051 {
23052 PyThreadState* __tstate = wxPyBeginAllowThreads();
23053 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 {
23058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23059 }
23060 return resultobj;
23061 fail:
23062 return NULL;
23063 }
23064
23065
23066 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23067 PyObject *resultobj = 0;
23068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23069 bool result;
23070 void *argp1 = 0 ;
23071 int res1 = 0 ;
23072 PyObject *swig_obj[1] ;
23073
23074 if (!args) SWIG_fail;
23075 swig_obj[0] = args;
23076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23077 if (!SWIG_IsOK(res1)) {
23078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23079 }
23080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 {
23088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23089 }
23090 return resultobj;
23091 fail:
23092 return NULL;
23093 }
23094
23095
23096 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23097 PyObject *resultobj = 0;
23098 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23099 bool result;
23100 void *argp1 = 0 ;
23101 int res1 = 0 ;
23102 PyObject *swig_obj[1] ;
23103
23104 if (!args) SWIG_fail;
23105 swig_obj[0] = args;
23106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23107 if (!SWIG_IsOK(res1)) {
23108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23109 }
23110 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 {
23118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23119 }
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23127 PyObject *resultobj = 0;
23128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23129 bool result;
23130 void *argp1 = 0 ;
23131 int res1 = 0 ;
23132 PyObject *swig_obj[1] ;
23133
23134 if (!args) SWIG_fail;
23135 swig_obj[0] = args;
23136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23137 if (!SWIG_IsOK(res1)) {
23138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23139 }
23140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23141 {
23142 PyThreadState* __tstate = wxPyBeginAllowThreads();
23143 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23144 wxPyEndAllowThreads(__tstate);
23145 if (PyErr_Occurred()) SWIG_fail;
23146 }
23147 {
23148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23149 }
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 PyObject *resultobj = 0;
23158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23159 bool result;
23160 void *argp1 = 0 ;
23161 int res1 = 0 ;
23162 PyObject *swig_obj[1] ;
23163
23164 if (!args) SWIG_fail;
23165 swig_obj[0] = args;
23166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23167 if (!SWIG_IsOK(res1)) {
23168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23169 }
23170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 {
23178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23179 }
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23187 PyObject *resultobj = 0;
23188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23189 bool result;
23190 void *argp1 = 0 ;
23191 int res1 = 0 ;
23192 PyObject *swig_obj[1] ;
23193
23194 if (!args) SWIG_fail;
23195 swig_obj[0] = args;
23196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23197 if (!SWIG_IsOK(res1)) {
23198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23199 }
23200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23217 PyObject *resultobj = 0;
23218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23219 bool result;
23220 void *argp1 = 0 ;
23221 int res1 = 0 ;
23222 PyObject *swig_obj[1] ;
23223
23224 if (!args) SWIG_fail;
23225 swig_obj[0] = args;
23226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23227 if (!SWIG_IsOK(res1)) {
23228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23229 }
23230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23247 PyObject *resultobj = 0;
23248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23249 bool result;
23250 void *argp1 = 0 ;
23251 int res1 = 0 ;
23252 PyObject *swig_obj[1] ;
23253
23254 if (!args) SWIG_fail;
23255 swig_obj[0] = args;
23256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23257 if (!SWIG_IsOK(res1)) {
23258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23259 }
23260 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23261 {
23262 PyThreadState* __tstate = wxPyBeginAllowThreads();
23263 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23264 wxPyEndAllowThreads(__tstate);
23265 if (PyErr_Occurred()) SWIG_fail;
23266 }
23267 {
23268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23269 }
23270 return resultobj;
23271 fail:
23272 return NULL;
23273 }
23274
23275
23276 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23277 PyObject *resultobj = 0;
23278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23279 bool result;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 PyObject *swig_obj[1] ;
23283
23284 if (!args) SWIG_fail;
23285 swig_obj[0] = args;
23286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23287 if (!SWIG_IsOK(res1)) {
23288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23289 }
23290 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23294 wxPyEndAllowThreads(__tstate);
23295 if (PyErr_Occurred()) SWIG_fail;
23296 }
23297 {
23298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23299 }
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 PyObject *resultobj = 0;
23308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23309 bool result;
23310 void *argp1 = 0 ;
23311 int res1 = 0 ;
23312 PyObject *swig_obj[1] ;
23313
23314 if (!args) SWIG_fail;
23315 swig_obj[0] = args;
23316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23319 }
23320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 {
23328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23329 }
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23337 PyObject *resultobj = 0;
23338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23339 bool result;
23340 void *argp1 = 0 ;
23341 int res1 = 0 ;
23342 PyObject *swig_obj[1] ;
23343
23344 if (!args) SWIG_fail;
23345 swig_obj[0] = args;
23346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23347 if (!SWIG_IsOK(res1)) {
23348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23349 }
23350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 {
23358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23359 }
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 PyObject *resultobj = 0;
23368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23369 bool result;
23370 void *argp1 = 0 ;
23371 int res1 = 0 ;
23372 PyObject *swig_obj[1] ;
23373
23374 if (!args) SWIG_fail;
23375 swig_obj[0] = args;
23376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23377 if (!SWIG_IsOK(res1)) {
23378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23379 }
23380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23384 wxPyEndAllowThreads(__tstate);
23385 if (PyErr_Occurred()) SWIG_fail;
23386 }
23387 {
23388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23389 }
23390 return resultobj;
23391 fail:
23392 return NULL;
23393 }
23394
23395
23396 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23397 PyObject *resultobj = 0;
23398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23399 bool result;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 PyObject *swig_obj[1] ;
23403
23404 if (!args) SWIG_fail;
23405 swig_obj[0] = args;
23406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23409 }
23410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23411 {
23412 PyThreadState* __tstate = wxPyBeginAllowThreads();
23413 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23419 }
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *resultobj = 0;
23428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23429 bool result;
23430 void *argp1 = 0 ;
23431 int res1 = 0 ;
23432 PyObject *swig_obj[1] ;
23433
23434 if (!args) SWIG_fail;
23435 swig_obj[0] = args;
23436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23437 if (!SWIG_IsOK(res1)) {
23438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23439 }
23440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23441 {
23442 PyThreadState* __tstate = wxPyBeginAllowThreads();
23443 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 {
23448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23449 }
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *resultobj = 0;
23458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23459 bool result;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 PyObject *swig_obj[1] ;
23463
23464 if (!args) SWIG_fail;
23465 swig_obj[0] = args;
23466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23467 if (!SWIG_IsOK(res1)) {
23468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23469 }
23470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23471 {
23472 PyThreadState* __tstate = wxPyBeginAllowThreads();
23473 result = (bool)(arg1)->LeftIsDown();
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 {
23478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23479 }
23480 return resultobj;
23481 fail:
23482 return NULL;
23483 }
23484
23485
23486 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23487 PyObject *resultobj = 0;
23488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23489 bool result;
23490 void *argp1 = 0 ;
23491 int res1 = 0 ;
23492 PyObject *swig_obj[1] ;
23493
23494 if (!args) SWIG_fail;
23495 swig_obj[0] = args;
23496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23497 if (!SWIG_IsOK(res1)) {
23498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23499 }
23500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 result = (bool)(arg1)->MiddleIsDown();
23504 wxPyEndAllowThreads(__tstate);
23505 if (PyErr_Occurred()) SWIG_fail;
23506 }
23507 {
23508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23509 }
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *resultobj = 0;
23518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23519 bool result;
23520 void *argp1 = 0 ;
23521 int res1 = 0 ;
23522 PyObject *swig_obj[1] ;
23523
23524 if (!args) SWIG_fail;
23525 swig_obj[0] = args;
23526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23527 if (!SWIG_IsOK(res1)) {
23528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23529 }
23530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23531 {
23532 PyThreadState* __tstate = wxPyBeginAllowThreads();
23533 result = (bool)(arg1)->RightIsDown();
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 {
23538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23539 }
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23547 PyObject *resultobj = 0;
23548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23549 bool result;
23550 void *argp1 = 0 ;
23551 int res1 = 0 ;
23552 PyObject *swig_obj[1] ;
23553
23554 if (!args) SWIG_fail;
23555 swig_obj[0] = args;
23556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23557 if (!SWIG_IsOK(res1)) {
23558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23559 }
23560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 {
23568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23577 PyObject *resultobj = 0;
23578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23579 bool result;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 PyObject *swig_obj[1] ;
23583
23584 if (!args) SWIG_fail;
23585 swig_obj[0] = args;
23586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23587 if (!SWIG_IsOK(res1)) {
23588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23589 }
23590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 {
23598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23599 }
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23609 bool result;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 PyObject *swig_obj[1] ;
23613
23614 if (!args) SWIG_fail;
23615 swig_obj[0] = args;
23616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23619 }
23620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 {
23628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23629 }
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23637 PyObject *resultobj = 0;
23638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23639 bool result;
23640 void *argp1 = 0 ;
23641 int res1 = 0 ;
23642 PyObject *swig_obj[1] ;
23643
23644 if (!args) SWIG_fail;
23645 swig_obj[0] = args;
23646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23647 if (!SWIG_IsOK(res1)) {
23648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23649 }
23650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23651 {
23652 PyThreadState* __tstate = wxPyBeginAllowThreads();
23653 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23654 wxPyEndAllowThreads(__tstate);
23655 if (PyErr_Occurred()) SWIG_fail;
23656 }
23657 {
23658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23659 }
23660 return resultobj;
23661 fail:
23662 return NULL;
23663 }
23664
23665
23666 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23667 PyObject *resultobj = 0;
23668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23669 wxPoint result;
23670 void *argp1 = 0 ;
23671 int res1 = 0 ;
23672 PyObject *swig_obj[1] ;
23673
23674 if (!args) SWIG_fail;
23675 swig_obj[0] = args;
23676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23677 if (!SWIG_IsOK(res1)) {
23678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23679 }
23680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (arg1)->GetPosition();
23684 wxPyEndAllowThreads(__tstate);
23685 if (PyErr_Occurred()) SWIG_fail;
23686 }
23687 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23688 return resultobj;
23689 fail:
23690 return NULL;
23691 }
23692
23693
23694 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23695 PyObject *resultobj = 0;
23696 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23697 long *arg2 = (long *) 0 ;
23698 long *arg3 = (long *) 0 ;
23699 void *argp1 = 0 ;
23700 int res1 = 0 ;
23701 long temp2 ;
23702 int res2 = SWIG_TMPOBJ ;
23703 long temp3 ;
23704 int res3 = SWIG_TMPOBJ ;
23705 PyObject *swig_obj[1] ;
23706
23707 arg2 = &temp2;
23708 arg3 = &temp3;
23709 if (!args) SWIG_fail;
23710 swig_obj[0] = args;
23711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23714 }
23715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 (arg1)->GetPosition(arg2,arg3);
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 resultobj = SWIG_Py_Void();
23723 if (SWIG_IsTmpObj(res2)) {
23724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23725 } else {
23726 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23728 }
23729 if (SWIG_IsTmpObj(res3)) {
23730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23731 } else {
23732 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23734 }
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj = 0;
23743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23744 wxDC *arg2 = 0 ;
23745 wxPoint result;
23746 void *argp1 = 0 ;
23747 int res1 = 0 ;
23748 void *argp2 = 0 ;
23749 int res2 = 0 ;
23750 PyObject * obj0 = 0 ;
23751 PyObject * obj1 = 0 ;
23752 char * kwnames[] = {
23753 (char *) "self",(char *) "dc", NULL
23754 };
23755
23756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23758 if (!SWIG_IsOK(res1)) {
23759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23760 }
23761 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23763 if (!SWIG_IsOK(res2)) {
23764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23765 }
23766 if (!argp2) {
23767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23768 }
23769 arg2 = reinterpret_cast< wxDC * >(argp2);
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23773 wxPyEndAllowThreads(__tstate);
23774 if (PyErr_Occurred()) SWIG_fail;
23775 }
23776 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23777 return resultobj;
23778 fail:
23779 return NULL;
23780 }
23781
23782
23783 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23784 PyObject *resultobj = 0;
23785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23786 int result;
23787 void *argp1 = 0 ;
23788 int res1 = 0 ;
23789 PyObject *swig_obj[1] ;
23790
23791 if (!args) SWIG_fail;
23792 swig_obj[0] = args;
23793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23794 if (!SWIG_IsOK(res1)) {
23795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23796 }
23797 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 result = (int)((wxMouseEvent const *)arg1)->GetX();
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 resultobj = SWIG_From_int(static_cast< int >(result));
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23812 PyObject *resultobj = 0;
23813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23814 int result;
23815 void *argp1 = 0 ;
23816 int res1 = 0 ;
23817 PyObject *swig_obj[1] ;
23818
23819 if (!args) SWIG_fail;
23820 swig_obj[0] = args;
23821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23822 if (!SWIG_IsOK(res1)) {
23823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23824 }
23825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = (int)((wxMouseEvent const *)arg1)->GetY();
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_From_int(static_cast< int >(result));
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23842 int result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_From_int(static_cast< int >(result));
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23870 int result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_From_int(static_cast< int >(result));
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896 PyObject *resultobj = 0;
23897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23898 int result;
23899 void *argp1 = 0 ;
23900 int res1 = 0 ;
23901 PyObject *swig_obj[1] ;
23902
23903 if (!args) SWIG_fail;
23904 swig_obj[0] = args;
23905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23906 if (!SWIG_IsOK(res1)) {
23907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23908 }
23909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 resultobj = SWIG_From_int(static_cast< int >(result));
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23924 PyObject *resultobj = 0;
23925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23926 bool result;
23927 void *argp1 = 0 ;
23928 int res1 = 0 ;
23929 PyObject *swig_obj[1] ;
23930
23931 if (!args) SWIG_fail;
23932 swig_obj[0] = args;
23933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23934 if (!SWIG_IsOK(res1)) {
23935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23936 }
23937 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 {
23945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23946 }
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23954 PyObject *resultobj = 0;
23955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23956 int arg2 ;
23957 void *argp1 = 0 ;
23958 int res1 = 0 ;
23959 int val2 ;
23960 int ecode2 = 0 ;
23961 PyObject *swig_obj[2] ;
23962
23963 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23965 if (!SWIG_IsOK(res1)) {
23966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23967 }
23968 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23970 if (!SWIG_IsOK(ecode2)) {
23971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23972 }
23973 arg2 = static_cast< int >(val2);
23974 if (arg1) (arg1)->m_x = arg2;
23975
23976 resultobj = SWIG_Py_Void();
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23984 PyObject *resultobj = 0;
23985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23986 int result;
23987 void *argp1 = 0 ;
23988 int res1 = 0 ;
23989 PyObject *swig_obj[1] ;
23990
23991 if (!args) SWIG_fail;
23992 swig_obj[0] = args;
23993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23994 if (!SWIG_IsOK(res1)) {
23995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23996 }
23997 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23998 result = (int) ((arg1)->m_x);
23999 resultobj = SWIG_From_int(static_cast< int >(result));
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24007 PyObject *resultobj = 0;
24008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24009 int arg2 ;
24010 void *argp1 = 0 ;
24011 int res1 = 0 ;
24012 int val2 ;
24013 int ecode2 = 0 ;
24014 PyObject *swig_obj[2] ;
24015
24016 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24018 if (!SWIG_IsOK(res1)) {
24019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24020 }
24021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24023 if (!SWIG_IsOK(ecode2)) {
24024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24025 }
24026 arg2 = static_cast< int >(val2);
24027 if (arg1) (arg1)->m_y = arg2;
24028
24029 resultobj = SWIG_Py_Void();
24030 return resultobj;
24031 fail:
24032 return NULL;
24033 }
24034
24035
24036 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24037 PyObject *resultobj = 0;
24038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24039 int result;
24040 void *argp1 = 0 ;
24041 int res1 = 0 ;
24042 PyObject *swig_obj[1] ;
24043
24044 if (!args) SWIG_fail;
24045 swig_obj[0] = args;
24046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24047 if (!SWIG_IsOK(res1)) {
24048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24049 }
24050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24051 result = (int) ((arg1)->m_y);
24052 resultobj = SWIG_From_int(static_cast< int >(result));
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24060 PyObject *resultobj = 0;
24061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24062 bool arg2 ;
24063 void *argp1 = 0 ;
24064 int res1 = 0 ;
24065 bool val2 ;
24066 int ecode2 = 0 ;
24067 PyObject *swig_obj[2] ;
24068
24069 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24071 if (!SWIG_IsOK(res1)) {
24072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24073 }
24074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24075 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24076 if (!SWIG_IsOK(ecode2)) {
24077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24078 }
24079 arg2 = static_cast< bool >(val2);
24080 if (arg1) (arg1)->m_leftDown = arg2;
24081
24082 resultobj = SWIG_Py_Void();
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24090 PyObject *resultobj = 0;
24091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24092 bool result;
24093 void *argp1 = 0 ;
24094 int res1 = 0 ;
24095 PyObject *swig_obj[1] ;
24096
24097 if (!args) SWIG_fail;
24098 swig_obj[0] = args;
24099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24100 if (!SWIG_IsOK(res1)) {
24101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24102 }
24103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24104 result = (bool) ((arg1)->m_leftDown);
24105 {
24106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24107 }
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 PyObject *resultobj = 0;
24116 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24117 bool arg2 ;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 bool val2 ;
24121 int ecode2 = 0 ;
24122 PyObject *swig_obj[2] ;
24123
24124 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24128 }
24129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24130 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24131 if (!SWIG_IsOK(ecode2)) {
24132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24133 }
24134 arg2 = static_cast< bool >(val2);
24135 if (arg1) (arg1)->m_middleDown = arg2;
24136
24137 resultobj = SWIG_Py_Void();
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24145 PyObject *resultobj = 0;
24146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24147 bool result;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 PyObject *swig_obj[1] ;
24151
24152 if (!args) SWIG_fail;
24153 swig_obj[0] = args;
24154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24157 }
24158 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24159 result = (bool) ((arg1)->m_middleDown);
24160 {
24161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24162 }
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24170 PyObject *resultobj = 0;
24171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24172 bool arg2 ;
24173 void *argp1 = 0 ;
24174 int res1 = 0 ;
24175 bool val2 ;
24176 int ecode2 = 0 ;
24177 PyObject *swig_obj[2] ;
24178
24179 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24181 if (!SWIG_IsOK(res1)) {
24182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24183 }
24184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24185 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24186 if (!SWIG_IsOK(ecode2)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24188 }
24189 arg2 = static_cast< bool >(val2);
24190 if (arg1) (arg1)->m_rightDown = arg2;
24191
24192 resultobj = SWIG_Py_Void();
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24200 PyObject *resultobj = 0;
24201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24202 bool result;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 PyObject *swig_obj[1] ;
24206
24207 if (!args) SWIG_fail;
24208 swig_obj[0] = args;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24214 result = (bool) ((arg1)->m_rightDown);
24215 {
24216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24217 }
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24225 PyObject *resultobj = 0;
24226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24227 bool arg2 ;
24228 void *argp1 = 0 ;
24229 int res1 = 0 ;
24230 bool val2 ;
24231 int ecode2 = 0 ;
24232 PyObject *swig_obj[2] ;
24233
24234 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24236 if (!SWIG_IsOK(res1)) {
24237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24238 }
24239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24240 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24241 if (!SWIG_IsOK(ecode2)) {
24242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24243 }
24244 arg2 = static_cast< bool >(val2);
24245 if (arg1) (arg1)->m_controlDown = arg2;
24246
24247 resultobj = SWIG_Py_Void();
24248 return resultobj;
24249 fail:
24250 return NULL;
24251 }
24252
24253
24254 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24255 PyObject *resultobj = 0;
24256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24257 bool result;
24258 void *argp1 = 0 ;
24259 int res1 = 0 ;
24260 PyObject *swig_obj[1] ;
24261
24262 if (!args) SWIG_fail;
24263 swig_obj[0] = args;
24264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24265 if (!SWIG_IsOK(res1)) {
24266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24267 }
24268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24269 result = (bool) ((arg1)->m_controlDown);
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24280 PyObject *resultobj = 0;
24281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24282 bool arg2 ;
24283 void *argp1 = 0 ;
24284 int res1 = 0 ;
24285 bool val2 ;
24286 int ecode2 = 0 ;
24287 PyObject *swig_obj[2] ;
24288
24289 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24291 if (!SWIG_IsOK(res1)) {
24292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24293 }
24294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24295 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24296 if (!SWIG_IsOK(ecode2)) {
24297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24298 }
24299 arg2 = static_cast< bool >(val2);
24300 if (arg1) (arg1)->m_shiftDown = arg2;
24301
24302 resultobj = SWIG_Py_Void();
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24312 bool result;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 PyObject *swig_obj[1] ;
24316
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24324 result = (bool) ((arg1)->m_shiftDown);
24325 {
24326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24327 }
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 PyObject *resultobj = 0;
24336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24337 bool arg2 ;
24338 void *argp1 = 0 ;
24339 int res1 = 0 ;
24340 bool val2 ;
24341 int ecode2 = 0 ;
24342 PyObject *swig_obj[2] ;
24343
24344 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24348 }
24349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24350 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24351 if (!SWIG_IsOK(ecode2)) {
24352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24353 }
24354 arg2 = static_cast< bool >(val2);
24355 if (arg1) (arg1)->m_altDown = arg2;
24356
24357 resultobj = SWIG_Py_Void();
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24365 PyObject *resultobj = 0;
24366 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24367 bool result;
24368 void *argp1 = 0 ;
24369 int res1 = 0 ;
24370 PyObject *swig_obj[1] ;
24371
24372 if (!args) SWIG_fail;
24373 swig_obj[0] = args;
24374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24377 }
24378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24379 result = (bool) ((arg1)->m_altDown);
24380 {
24381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24382 }
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24390 PyObject *resultobj = 0;
24391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24392 bool arg2 ;
24393 void *argp1 = 0 ;
24394 int res1 = 0 ;
24395 bool val2 ;
24396 int ecode2 = 0 ;
24397 PyObject *swig_obj[2] ;
24398
24399 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24401 if (!SWIG_IsOK(res1)) {
24402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24403 }
24404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24405 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24406 if (!SWIG_IsOK(ecode2)) {
24407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24408 }
24409 arg2 = static_cast< bool >(val2);
24410 if (arg1) (arg1)->m_metaDown = arg2;
24411
24412 resultobj = SWIG_Py_Void();
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24420 PyObject *resultobj = 0;
24421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24422 bool result;
24423 void *argp1 = 0 ;
24424 int res1 = 0 ;
24425 PyObject *swig_obj[1] ;
24426
24427 if (!args) SWIG_fail;
24428 swig_obj[0] = args;
24429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24430 if (!SWIG_IsOK(res1)) {
24431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24432 }
24433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24434 result = (bool) ((arg1)->m_metaDown);
24435 {
24436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24437 }
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24445 PyObject *resultobj = 0;
24446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24447 int arg2 ;
24448 void *argp1 = 0 ;
24449 int res1 = 0 ;
24450 int val2 ;
24451 int ecode2 = 0 ;
24452 PyObject *swig_obj[2] ;
24453
24454 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24456 if (!SWIG_IsOK(res1)) {
24457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24458 }
24459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24460 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24461 if (!SWIG_IsOK(ecode2)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24463 }
24464 arg2 = static_cast< int >(val2);
24465 if (arg1) (arg1)->m_wheelRotation = arg2;
24466
24467 resultobj = SWIG_Py_Void();
24468 return resultobj;
24469 fail:
24470 return NULL;
24471 }
24472
24473
24474 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24475 PyObject *resultobj = 0;
24476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24477 int result;
24478 void *argp1 = 0 ;
24479 int res1 = 0 ;
24480 PyObject *swig_obj[1] ;
24481
24482 if (!args) SWIG_fail;
24483 swig_obj[0] = args;
24484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24485 if (!SWIG_IsOK(res1)) {
24486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24487 }
24488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24489 result = (int) ((arg1)->m_wheelRotation);
24490 resultobj = SWIG_From_int(static_cast< int >(result));
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24498 PyObject *resultobj = 0;
24499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24500 int arg2 ;
24501 void *argp1 = 0 ;
24502 int res1 = 0 ;
24503 int val2 ;
24504 int ecode2 = 0 ;
24505 PyObject *swig_obj[2] ;
24506
24507 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24509 if (!SWIG_IsOK(res1)) {
24510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24511 }
24512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24513 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24514 if (!SWIG_IsOK(ecode2)) {
24515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24516 }
24517 arg2 = static_cast< int >(val2);
24518 if (arg1) (arg1)->m_wheelDelta = arg2;
24519
24520 resultobj = SWIG_Py_Void();
24521 return resultobj;
24522 fail:
24523 return NULL;
24524 }
24525
24526
24527 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24528 PyObject *resultobj = 0;
24529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24530 int result;
24531 void *argp1 = 0 ;
24532 int res1 = 0 ;
24533 PyObject *swig_obj[1] ;
24534
24535 if (!args) SWIG_fail;
24536 swig_obj[0] = args;
24537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24538 if (!SWIG_IsOK(res1)) {
24539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24540 }
24541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24542 result = (int) ((arg1)->m_wheelDelta);
24543 resultobj = SWIG_From_int(static_cast< int >(result));
24544 return resultobj;
24545 fail:
24546 return NULL;
24547 }
24548
24549
24550 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24551 PyObject *resultobj = 0;
24552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24553 int arg2 ;
24554 void *argp1 = 0 ;
24555 int res1 = 0 ;
24556 int val2 ;
24557 int ecode2 = 0 ;
24558 PyObject *swig_obj[2] ;
24559
24560 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24564 }
24565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24566 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24567 if (!SWIG_IsOK(ecode2)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24569 }
24570 arg2 = static_cast< int >(val2);
24571 if (arg1) (arg1)->m_linesPerAction = arg2;
24572
24573 resultobj = SWIG_Py_Void();
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24581 PyObject *resultobj = 0;
24582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24583 int result;
24584 void *argp1 = 0 ;
24585 int res1 = 0 ;
24586 PyObject *swig_obj[1] ;
24587
24588 if (!args) SWIG_fail;
24589 swig_obj[0] = args;
24590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24591 if (!SWIG_IsOK(res1)) {
24592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24593 }
24594 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24595 result = (int) ((arg1)->m_linesPerAction);
24596 resultobj = SWIG_From_int(static_cast< int >(result));
24597 return resultobj;
24598 fail:
24599 return NULL;
24600 }
24601
24602
24603 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24604 PyObject *obj;
24605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24606 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24607 return SWIG_Py_Void();
24608 }
24609
24610 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24611 return SWIG_Python_InitShadowInstance(args);
24612 }
24613
24614 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24615 PyObject *resultobj = 0;
24616 int arg1 = (int) 0 ;
24617 int arg2 = (int) 0 ;
24618 wxSetCursorEvent *result = 0 ;
24619 int val1 ;
24620 int ecode1 = 0 ;
24621 int val2 ;
24622 int ecode2 = 0 ;
24623 PyObject * obj0 = 0 ;
24624 PyObject * obj1 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "x",(char *) "y", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24630 if (obj0) {
24631 ecode1 = SWIG_AsVal_int(obj0, &val1);
24632 if (!SWIG_IsOK(ecode1)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24634 }
24635 arg1 = static_cast< int >(val1);
24636 }
24637 if (obj1) {
24638 ecode2 = SWIG_AsVal_int(obj1, &val2);
24639 if (!SWIG_IsOK(ecode2)) {
24640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24641 }
24642 arg2 = static_cast< int >(val2);
24643 }
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *resultobj = 0;
24659 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24660 int result;
24661 void *argp1 = 0 ;
24662 int res1 = 0 ;
24663 PyObject *swig_obj[1] ;
24664
24665 if (!args) SWIG_fail;
24666 swig_obj[0] = args;
24667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24670 }
24671 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 resultobj = SWIG_From_int(static_cast< int >(result));
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24686 PyObject *resultobj = 0;
24687 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24688 int result;
24689 void *argp1 = 0 ;
24690 int res1 = 0 ;
24691 PyObject *swig_obj[1] ;
24692
24693 if (!args) SWIG_fail;
24694 swig_obj[0] = args;
24695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24696 if (!SWIG_IsOK(res1)) {
24697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24698 }
24699 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 resultobj = SWIG_From_int(static_cast< int >(result));
24707 return resultobj;
24708 fail:
24709 return NULL;
24710 }
24711
24712
24713 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = 0;
24715 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24716 wxCursor *arg2 = 0 ;
24717 void *argp1 = 0 ;
24718 int res1 = 0 ;
24719 void *argp2 = 0 ;
24720 int res2 = 0 ;
24721 PyObject * obj0 = 0 ;
24722 PyObject * obj1 = 0 ;
24723 char * kwnames[] = {
24724 (char *) "self",(char *) "cursor", NULL
24725 };
24726
24727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24729 if (!SWIG_IsOK(res1)) {
24730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24731 }
24732 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24734 if (!SWIG_IsOK(res2)) {
24735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24736 }
24737 if (!argp2) {
24738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24739 }
24740 arg2 = reinterpret_cast< wxCursor * >(argp2);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 (arg1)->SetCursor((wxCursor const &)*arg2);
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 resultobj = SWIG_Py_Void();
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24757 wxCursor *result = 0 ;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 {
24772 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24773 result = (wxCursor *) &_result_ref;
24774 }
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 {
24779 wxCursor* resultptr = new wxCursor(*result);
24780 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24789 PyObject *resultobj = 0;
24790 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24791 bool result;
24792 void *argp1 = 0 ;
24793 int res1 = 0 ;
24794 PyObject *swig_obj[1] ;
24795
24796 if (!args) SWIG_fail;
24797 swig_obj[0] = args;
24798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24799 if (!SWIG_IsOK(res1)) {
24800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24801 }
24802 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24819 PyObject *obj;
24820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24821 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24822 return SWIG_Py_Void();
24823 }
24824
24825 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24826 return SWIG_Python_InitShadowInstance(args);
24827 }
24828
24829 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj = 0;
24831 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24832 wxKeyEvent *result = 0 ;
24833 int val1 ;
24834 int ecode1 = 0 ;
24835 PyObject * obj0 = 0 ;
24836 char * kwnames[] = {
24837 (char *) "eventType", NULL
24838 };
24839
24840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24841 if (obj0) {
24842 ecode1 = SWIG_AsVal_int(obj0, &val1);
24843 if (!SWIG_IsOK(ecode1)) {
24844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24845 }
24846 arg1 = static_cast< wxEventType >(val1);
24847 }
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24851 wxPyEndAllowThreads(__tstate);
24852 if (PyErr_Occurred()) SWIG_fail;
24853 }
24854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24864 int result;
24865 void *argp1 = 0 ;
24866 int res1 = 0 ;
24867 PyObject *swig_obj[1] ;
24868
24869 if (!args) SWIG_fail;
24870 swig_obj[0] = args;
24871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24874 }
24875 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 resultobj = SWIG_From_int(static_cast< int >(result));
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24892 bool result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24902 }
24903 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24912 }
24913 return resultobj;
24914 fail:
24915 return NULL;
24916 }
24917
24918
24919 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24920 PyObject *resultobj = 0;
24921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24922 bool result;
24923 void *argp1 = 0 ;
24924 int res1 = 0 ;
24925 PyObject *swig_obj[1] ;
24926
24927 if (!args) SWIG_fail;
24928 swig_obj[0] = args;
24929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24930 if (!SWIG_IsOK(res1)) {
24931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24932 }
24933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24937 wxPyEndAllowThreads(__tstate);
24938 if (PyErr_Occurred()) SWIG_fail;
24939 }
24940 {
24941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24942 }
24943 return resultobj;
24944 fail:
24945 return NULL;
24946 }
24947
24948
24949 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24950 PyObject *resultobj = 0;
24951 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24952 bool result;
24953 void *argp1 = 0 ;
24954 int res1 = 0 ;
24955 PyObject *swig_obj[1] ;
24956
24957 if (!args) SWIG_fail;
24958 swig_obj[0] = args;
24959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24960 if (!SWIG_IsOK(res1)) {
24961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24962 }
24963 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 {
24971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24972 }
24973 return resultobj;
24974 fail:
24975 return NULL;
24976 }
24977
24978
24979 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24980 PyObject *resultobj = 0;
24981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24982 bool result;
24983 void *argp1 = 0 ;
24984 int res1 = 0 ;
24985 PyObject *swig_obj[1] ;
24986
24987 if (!args) SWIG_fail;
24988 swig_obj[0] = args;
24989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24990 if (!SWIG_IsOK(res1)) {
24991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24992 }
24993 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24997 wxPyEndAllowThreads(__tstate);
24998 if (PyErr_Occurred()) SWIG_fail;
24999 }
25000 {
25001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25002 }
25003 return resultobj;
25004 fail:
25005 return NULL;
25006 }
25007
25008
25009 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25010 PyObject *resultobj = 0;
25011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25012 bool result;
25013 void *argp1 = 0 ;
25014 int res1 = 0 ;
25015 PyObject *swig_obj[1] ;
25016
25017 if (!args) SWIG_fail;
25018 swig_obj[0] = args;
25019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25020 if (!SWIG_IsOK(res1)) {
25021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25022 }
25023 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25024 {
25025 PyThreadState* __tstate = wxPyBeginAllowThreads();
25026 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25027 wxPyEndAllowThreads(__tstate);
25028 if (PyErr_Occurred()) SWIG_fail;
25029 }
25030 {
25031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25032 }
25033 return resultobj;
25034 fail:
25035 return NULL;
25036 }
25037
25038
25039 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25040 PyObject *resultobj = 0;
25041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25042 bool result;
25043 void *argp1 = 0 ;
25044 int res1 = 0 ;
25045 PyObject *swig_obj[1] ;
25046
25047 if (!args) SWIG_fail;
25048 swig_obj[0] = args;
25049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25050 if (!SWIG_IsOK(res1)) {
25051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25052 }
25053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25054 {
25055 PyThreadState* __tstate = wxPyBeginAllowThreads();
25056 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25057 wxPyEndAllowThreads(__tstate);
25058 if (PyErr_Occurred()) SWIG_fail;
25059 }
25060 {
25061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25062 }
25063 return resultobj;
25064 fail:
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25070 PyObject *resultobj = 0;
25071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25072 int result;
25073 void *argp1 = 0 ;
25074 int res1 = 0 ;
25075 PyObject *swig_obj[1] ;
25076
25077 if (!args) SWIG_fail;
25078 swig_obj[0] = args;
25079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25080 if (!SWIG_IsOK(res1)) {
25081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25082 }
25083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_From_int(static_cast< int >(result));
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098 PyObject *resultobj = 0;
25099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25100 int result;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 PyObject *swig_obj[1] ;
25104
25105 if (!args) SWIG_fail;
25106 swig_obj[0] = args;
25107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25108 if (!SWIG_IsOK(res1)) {
25109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25110 }
25111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 resultobj = SWIG_From_int(static_cast< int >(result));
25119 return resultobj;
25120 fail:
25121 return NULL;
25122 }
25123
25124
25125 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj = 0;
25127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25128 int arg2 ;
25129 void *argp1 = 0 ;
25130 int res1 = 0 ;
25131 int val2 ;
25132 int ecode2 = 0 ;
25133 PyObject * obj0 = 0 ;
25134 PyObject * obj1 = 0 ;
25135 char * kwnames[] = {
25136 (char *) "self",(char *) "uniChar", NULL
25137 };
25138
25139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25141 if (!SWIG_IsOK(res1)) {
25142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25143 }
25144 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25145 ecode2 = SWIG_AsVal_int(obj1, &val2);
25146 if (!SWIG_IsOK(ecode2)) {
25147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25148 }
25149 arg2 = static_cast< int >(val2);
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 resultobj = SWIG_Py_Void();
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25164 PyObject *resultobj = 0;
25165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25166 unsigned int result;
25167 void *argp1 = 0 ;
25168 int res1 = 0 ;
25169 PyObject *swig_obj[1] ;
25170
25171 if (!args) SWIG_fail;
25172 swig_obj[0] = args;
25173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25174 if (!SWIG_IsOK(res1)) {
25175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25176 }
25177 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25192 PyObject *resultobj = 0;
25193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25194 unsigned int result;
25195 void *argp1 = 0 ;
25196 int res1 = 0 ;
25197 PyObject *swig_obj[1] ;
25198
25199 if (!args) SWIG_fail;
25200 swig_obj[0] = args;
25201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25202 if (!SWIG_IsOK(res1)) {
25203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25204 }
25205 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25206 {
25207 PyThreadState* __tstate = wxPyBeginAllowThreads();
25208 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25209 wxPyEndAllowThreads(__tstate);
25210 if (PyErr_Occurred()) SWIG_fail;
25211 }
25212 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25213 return resultobj;
25214 fail:
25215 return NULL;
25216 }
25217
25218
25219 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 PyObject *resultobj = 0;
25221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25222 wxPoint result;
25223 void *argp1 = 0 ;
25224 int res1 = 0 ;
25225 PyObject *swig_obj[1] ;
25226
25227 if (!args) SWIG_fail;
25228 swig_obj[0] = args;
25229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25230 if (!SWIG_IsOK(res1)) {
25231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25232 }
25233 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (arg1)->GetPosition();
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25250 long *arg2 = (long *) 0 ;
25251 long *arg3 = (long *) 0 ;
25252 void *argp1 = 0 ;
25253 int res1 = 0 ;
25254 long temp2 ;
25255 int res2 = SWIG_TMPOBJ ;
25256 long temp3 ;
25257 int res3 = SWIG_TMPOBJ ;
25258 PyObject *swig_obj[1] ;
25259
25260 arg2 = &temp2;
25261 arg3 = &temp3;
25262 if (!args) SWIG_fail;
25263 swig_obj[0] = args;
25264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25265 if (!SWIG_IsOK(res1)) {
25266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25267 }
25268 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25269 {
25270 PyThreadState* __tstate = wxPyBeginAllowThreads();
25271 (arg1)->GetPosition(arg2,arg3);
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 resultobj = SWIG_Py_Void();
25276 if (SWIG_IsTmpObj(res2)) {
25277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25278 } else {
25279 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25281 }
25282 if (SWIG_IsTmpObj(res3)) {
25283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25284 } else {
25285 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25287 }
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25297 int result;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (int)((wxKeyEvent const *)arg1)->GetX();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 resultobj = SWIG_From_int(static_cast< int >(result));
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25323 PyObject *resultobj = 0;
25324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25325 int result;
25326 void *argp1 = 0 ;
25327 int res1 = 0 ;
25328 PyObject *swig_obj[1] ;
25329
25330 if (!args) SWIG_fail;
25331 swig_obj[0] = args;
25332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25335 }
25336 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (int)((wxKeyEvent const *)arg1)->GetY();
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_From_int(static_cast< int >(result));
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 PyObject *resultobj = 0;
25352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25353 int arg2 ;
25354 void *argp1 = 0 ;
25355 int res1 = 0 ;
25356 int val2 ;
25357 int ecode2 = 0 ;
25358 PyObject *swig_obj[2] ;
25359
25360 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25362 if (!SWIG_IsOK(res1)) {
25363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25364 }
25365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25366 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25367 if (!SWIG_IsOK(ecode2)) {
25368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25369 }
25370 arg2 = static_cast< int >(val2);
25371 if (arg1) (arg1)->m_x = arg2;
25372
25373 resultobj = SWIG_Py_Void();
25374 return resultobj;
25375 fail:
25376 return NULL;
25377 }
25378
25379
25380 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25381 PyObject *resultobj = 0;
25382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25383 int result;
25384 void *argp1 = 0 ;
25385 int res1 = 0 ;
25386 PyObject *swig_obj[1] ;
25387
25388 if (!args) SWIG_fail;
25389 swig_obj[0] = args;
25390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25391 if (!SWIG_IsOK(res1)) {
25392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25393 }
25394 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25395 result = (int) ((arg1)->m_x);
25396 resultobj = SWIG_From_int(static_cast< int >(result));
25397 return resultobj;
25398 fail:
25399 return NULL;
25400 }
25401
25402
25403 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25404 PyObject *resultobj = 0;
25405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25406 int arg2 ;
25407 void *argp1 = 0 ;
25408 int res1 = 0 ;
25409 int val2 ;
25410 int ecode2 = 0 ;
25411 PyObject *swig_obj[2] ;
25412
25413 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25415 if (!SWIG_IsOK(res1)) {
25416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25417 }
25418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25419 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25420 if (!SWIG_IsOK(ecode2)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25422 }
25423 arg2 = static_cast< int >(val2);
25424 if (arg1) (arg1)->m_y = arg2;
25425
25426 resultobj = SWIG_Py_Void();
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 PyObject *resultobj = 0;
25435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25436 int result;
25437 void *argp1 = 0 ;
25438 int res1 = 0 ;
25439 PyObject *swig_obj[1] ;
25440
25441 if (!args) SWIG_fail;
25442 swig_obj[0] = args;
25443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25444 if (!SWIG_IsOK(res1)) {
25445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25446 }
25447 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25448 result = (int) ((arg1)->m_y);
25449 resultobj = SWIG_From_int(static_cast< int >(result));
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 PyObject *resultobj = 0;
25458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25459 long arg2 ;
25460 void *argp1 = 0 ;
25461 int res1 = 0 ;
25462 long val2 ;
25463 int ecode2 = 0 ;
25464 PyObject *swig_obj[2] ;
25465
25466 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25468 if (!SWIG_IsOK(res1)) {
25469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25470 }
25471 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25472 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25473 if (!SWIG_IsOK(ecode2)) {
25474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25475 }
25476 arg2 = static_cast< long >(val2);
25477 if (arg1) (arg1)->m_keyCode = arg2;
25478
25479 resultobj = SWIG_Py_Void();
25480 return resultobj;
25481 fail:
25482 return NULL;
25483 }
25484
25485
25486 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25487 PyObject *resultobj = 0;
25488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25489 long result;
25490 void *argp1 = 0 ;
25491 int res1 = 0 ;
25492 PyObject *swig_obj[1] ;
25493
25494 if (!args) SWIG_fail;
25495 swig_obj[0] = args;
25496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25499 }
25500 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25501 result = (long) ((arg1)->m_keyCode);
25502 resultobj = SWIG_From_long(static_cast< long >(result));
25503 return resultobj;
25504 fail:
25505 return NULL;
25506 }
25507
25508
25509 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 PyObject *resultobj = 0;
25511 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25512 bool arg2 ;
25513 void *argp1 = 0 ;
25514 int res1 = 0 ;
25515 bool val2 ;
25516 int ecode2 = 0 ;
25517 PyObject *swig_obj[2] ;
25518
25519 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25521 if (!SWIG_IsOK(res1)) {
25522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25523 }
25524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25525 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25526 if (!SWIG_IsOK(ecode2)) {
25527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25528 }
25529 arg2 = static_cast< bool >(val2);
25530 if (arg1) (arg1)->m_controlDown = arg2;
25531
25532 resultobj = SWIG_Py_Void();
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25540 PyObject *resultobj = 0;
25541 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25542 bool result;
25543 void *argp1 = 0 ;
25544 int res1 = 0 ;
25545 PyObject *swig_obj[1] ;
25546
25547 if (!args) SWIG_fail;
25548 swig_obj[0] = args;
25549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25550 if (!SWIG_IsOK(res1)) {
25551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25552 }
25553 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25554 result = (bool) ((arg1)->m_controlDown);
25555 {
25556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25557 }
25558 return resultobj;
25559 fail:
25560 return NULL;
25561 }
25562
25563
25564 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25565 PyObject *resultobj = 0;
25566 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25567 bool arg2 ;
25568 void *argp1 = 0 ;
25569 int res1 = 0 ;
25570 bool val2 ;
25571 int ecode2 = 0 ;
25572 PyObject *swig_obj[2] ;
25573
25574 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25576 if (!SWIG_IsOK(res1)) {
25577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25578 }
25579 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25580 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25581 if (!SWIG_IsOK(ecode2)) {
25582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25583 }
25584 arg2 = static_cast< bool >(val2);
25585 if (arg1) (arg1)->m_shiftDown = arg2;
25586
25587 resultobj = SWIG_Py_Void();
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 PyObject *resultobj = 0;
25596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25597 bool result;
25598 void *argp1 = 0 ;
25599 int res1 = 0 ;
25600 PyObject *swig_obj[1] ;
25601
25602 if (!args) SWIG_fail;
25603 swig_obj[0] = args;
25604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25607 }
25608 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25609 result = (bool) ((arg1)->m_shiftDown);
25610 {
25611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25612 }
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25620 PyObject *resultobj = 0;
25621 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25622 bool arg2 ;
25623 void *argp1 = 0 ;
25624 int res1 = 0 ;
25625 bool val2 ;
25626 int ecode2 = 0 ;
25627 PyObject *swig_obj[2] ;
25628
25629 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25631 if (!SWIG_IsOK(res1)) {
25632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25633 }
25634 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25635 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25636 if (!SWIG_IsOK(ecode2)) {
25637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25638 }
25639 arg2 = static_cast< bool >(val2);
25640 if (arg1) (arg1)->m_altDown = arg2;
25641
25642 resultobj = SWIG_Py_Void();
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 PyObject *resultobj = 0;
25651 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25652 bool result;
25653 void *argp1 = 0 ;
25654 int res1 = 0 ;
25655 PyObject *swig_obj[1] ;
25656
25657 if (!args) SWIG_fail;
25658 swig_obj[0] = args;
25659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25660 if (!SWIG_IsOK(res1)) {
25661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25662 }
25663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25664 result = (bool) ((arg1)->m_altDown);
25665 {
25666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25667 }
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25675 PyObject *resultobj = 0;
25676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25677 bool arg2 ;
25678 void *argp1 = 0 ;
25679 int res1 = 0 ;
25680 bool val2 ;
25681 int ecode2 = 0 ;
25682 PyObject *swig_obj[2] ;
25683
25684 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25686 if (!SWIG_IsOK(res1)) {
25687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25688 }
25689 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25690 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25691 if (!SWIG_IsOK(ecode2)) {
25692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25693 }
25694 arg2 = static_cast< bool >(val2);
25695 if (arg1) (arg1)->m_metaDown = arg2;
25696
25697 resultobj = SWIG_Py_Void();
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25705 PyObject *resultobj = 0;
25706 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25707 bool result;
25708 void *argp1 = 0 ;
25709 int res1 = 0 ;
25710 PyObject *swig_obj[1] ;
25711
25712 if (!args) SWIG_fail;
25713 swig_obj[0] = args;
25714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25717 }
25718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25719 result = (bool) ((arg1)->m_metaDown);
25720 {
25721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25722 }
25723 return resultobj;
25724 fail:
25725 return NULL;
25726 }
25727
25728
25729 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25730 PyObject *resultobj = 0;
25731 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25732 bool arg2 ;
25733 void *argp1 = 0 ;
25734 int res1 = 0 ;
25735 bool val2 ;
25736 int ecode2 = 0 ;
25737 PyObject *swig_obj[2] ;
25738
25739 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25741 if (!SWIG_IsOK(res1)) {
25742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25743 }
25744 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25745 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25746 if (!SWIG_IsOK(ecode2)) {
25747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25748 }
25749 arg2 = static_cast< bool >(val2);
25750 if (arg1) (arg1)->m_scanCode = arg2;
25751
25752 resultobj = SWIG_Py_Void();
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25760 PyObject *resultobj = 0;
25761 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25762 bool result;
25763 void *argp1 = 0 ;
25764 int res1 = 0 ;
25765 PyObject *swig_obj[1] ;
25766
25767 if (!args) SWIG_fail;
25768 swig_obj[0] = args;
25769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25772 }
25773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25774 result = (bool) ((arg1)->m_scanCode);
25775 {
25776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25777 }
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25785 PyObject *resultobj = 0;
25786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25787 unsigned int arg2 ;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 unsigned int val2 ;
25791 int ecode2 = 0 ;
25792 PyObject *swig_obj[2] ;
25793
25794 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25796 if (!SWIG_IsOK(res1)) {
25797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25798 }
25799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25800 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25801 if (!SWIG_IsOK(ecode2)) {
25802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25803 }
25804 arg2 = static_cast< unsigned int >(val2);
25805 if (arg1) (arg1)->m_rawCode = arg2;
25806
25807 resultobj = SWIG_Py_Void();
25808 return resultobj;
25809 fail:
25810 return NULL;
25811 }
25812
25813
25814 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25815 PyObject *resultobj = 0;
25816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25817 unsigned int result;
25818 void *argp1 = 0 ;
25819 int res1 = 0 ;
25820 PyObject *swig_obj[1] ;
25821
25822 if (!args) SWIG_fail;
25823 swig_obj[0] = args;
25824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25829 result = (unsigned int) ((arg1)->m_rawCode);
25830 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25831 return resultobj;
25832 fail:
25833 return NULL;
25834 }
25835
25836
25837 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25838 PyObject *resultobj = 0;
25839 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25840 unsigned int arg2 ;
25841 void *argp1 = 0 ;
25842 int res1 = 0 ;
25843 unsigned int val2 ;
25844 int ecode2 = 0 ;
25845 PyObject *swig_obj[2] ;
25846
25847 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25849 if (!SWIG_IsOK(res1)) {
25850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25851 }
25852 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25853 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25854 if (!SWIG_IsOK(ecode2)) {
25855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25856 }
25857 arg2 = static_cast< unsigned int >(val2);
25858 if (arg1) (arg1)->m_rawFlags = arg2;
25859
25860 resultobj = SWIG_Py_Void();
25861 return resultobj;
25862 fail:
25863 return NULL;
25864 }
25865
25866
25867 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25868 PyObject *resultobj = 0;
25869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25870 unsigned int result;
25871 void *argp1 = 0 ;
25872 int res1 = 0 ;
25873 PyObject *swig_obj[1] ;
25874
25875 if (!args) SWIG_fail;
25876 swig_obj[0] = args;
25877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25878 if (!SWIG_IsOK(res1)) {
25879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25880 }
25881 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25882 result = (unsigned int) ((arg1)->m_rawFlags);
25883 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891 PyObject *obj;
25892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25893 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25894 return SWIG_Py_Void();
25895 }
25896
25897 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25898 return SWIG_Python_InitShadowInstance(args);
25899 }
25900
25901 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj = 0;
25903 wxSize const &arg1_defvalue = wxDefaultSize ;
25904 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25905 int arg2 = (int) 0 ;
25906 wxSizeEvent *result = 0 ;
25907 wxSize temp1 ;
25908 int val2 ;
25909 int ecode2 = 0 ;
25910 PyObject * obj0 = 0 ;
25911 PyObject * obj1 = 0 ;
25912 char * kwnames[] = {
25913 (char *) "sz",(char *) "winid", NULL
25914 };
25915
25916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25917 if (obj0) {
25918 {
25919 arg1 = &temp1;
25920 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25921 }
25922 }
25923 if (obj1) {
25924 ecode2 = SWIG_AsVal_int(obj1, &val2);
25925 if (!SWIG_IsOK(ecode2)) {
25926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25927 }
25928 arg2 = static_cast< int >(val2);
25929 }
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25944 PyObject *resultobj = 0;
25945 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25946 wxSize result;
25947 void *argp1 = 0 ;
25948 int res1 = 0 ;
25949 PyObject *swig_obj[1] ;
25950
25951 if (!args) SWIG_fail;
25952 swig_obj[0] = args;
25953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25954 if (!SWIG_IsOK(res1)) {
25955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25956 }
25957 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = ((wxSizeEvent const *)arg1)->GetSize();
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 PyObject *resultobj = 0;
25973 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25974 wxRect result;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 PyObject *swig_obj[1] ;
25978
25979 if (!args) SWIG_fail;
25980 swig_obj[0] = args;
25981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25984 }
25985 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = ((wxSizeEvent const *)arg1)->GetRect();
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25993 return resultobj;
25994 fail:
25995 return NULL;
25996 }
25997
25998
25999 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = 0;
26001 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26002 wxRect arg2 ;
26003 void *argp1 = 0 ;
26004 int res1 = 0 ;
26005 void *argp2 ;
26006 int res2 = 0 ;
26007 PyObject * obj0 = 0 ;
26008 PyObject * obj1 = 0 ;
26009 char * kwnames[] = {
26010 (char *) "self",(char *) "rect", NULL
26011 };
26012
26013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26015 if (!SWIG_IsOK(res1)) {
26016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26017 }
26018 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26019 {
26020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26021 if (!SWIG_IsOK(res2)) {
26022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26023 }
26024 if (!argp2) {
26025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26026 } else {
26027 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26028 arg2 = *temp;
26029 if (SWIG_IsNewObj(res2)) delete temp;
26030 }
26031 }
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 (arg1)->SetRect(arg2);
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 resultobj = SWIG_Py_Void();
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj = 0;
26047 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26048 wxSize arg2 ;
26049 void *argp1 = 0 ;
26050 int res1 = 0 ;
26051 void *argp2 ;
26052 int res2 = 0 ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 char * kwnames[] = {
26056 (char *) "self",(char *) "size", NULL
26057 };
26058
26059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26061 if (!SWIG_IsOK(res1)) {
26062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26063 }
26064 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26065 {
26066 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26067 if (!SWIG_IsOK(res2)) {
26068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26069 }
26070 if (!argp2) {
26071 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26072 } else {
26073 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26074 arg2 = *temp;
26075 if (SWIG_IsNewObj(res2)) delete temp;
26076 }
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 wxSizeEvent_SetSize(arg1,arg2);
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 resultobj = SWIG_Py_Void();
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26092 PyObject *resultobj = 0;
26093 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26094 wxSize *arg2 = (wxSize *) 0 ;
26095 void *argp1 = 0 ;
26096 int res1 = 0 ;
26097 void *argp2 = 0 ;
26098 int res2 = 0 ;
26099 PyObject *swig_obj[2] ;
26100
26101 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26103 if (!SWIG_IsOK(res1)) {
26104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26105 }
26106 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26107 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26108 if (!SWIG_IsOK(res2)) {
26109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26110 }
26111 arg2 = reinterpret_cast< wxSize * >(argp2);
26112 if (arg1) (arg1)->m_size = *arg2;
26113
26114 resultobj = SWIG_Py_Void();
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26122 PyObject *resultobj = 0;
26123 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26124 wxSize *result = 0 ;
26125 void *argp1 = 0 ;
26126 int res1 = 0 ;
26127 PyObject *swig_obj[1] ;
26128
26129 if (!args) SWIG_fail;
26130 swig_obj[0] = args;
26131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26134 }
26135 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26136 result = (wxSize *)& ((arg1)->m_size);
26137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26145 PyObject *resultobj = 0;
26146 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26147 wxRect *arg2 = (wxRect *) 0 ;
26148 void *argp1 = 0 ;
26149 int res1 = 0 ;
26150 void *argp2 = 0 ;
26151 int res2 = 0 ;
26152 PyObject *swig_obj[2] ;
26153
26154 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26158 }
26159 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26160 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26161 if (!SWIG_IsOK(res2)) {
26162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26163 }
26164 arg2 = reinterpret_cast< wxRect * >(argp2);
26165 if (arg1) (arg1)->m_rect = *arg2;
26166
26167 resultobj = SWIG_Py_Void();
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26175 PyObject *resultobj = 0;
26176 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26177 wxRect *result = 0 ;
26178 void *argp1 = 0 ;
26179 int res1 = 0 ;
26180 PyObject *swig_obj[1] ;
26181
26182 if (!args) SWIG_fail;
26183 swig_obj[0] = args;
26184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26185 if (!SWIG_IsOK(res1)) {
26186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26187 }
26188 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26189 result = (wxRect *)& ((arg1)->m_rect);
26190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26198 PyObject *obj;
26199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26200 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26201 return SWIG_Py_Void();
26202 }
26203
26204 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26205 return SWIG_Python_InitShadowInstance(args);
26206 }
26207
26208 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj = 0;
26210 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26211 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26212 int arg2 = (int) 0 ;
26213 wxMoveEvent *result = 0 ;
26214 wxPoint temp1 ;
26215 int val2 ;
26216 int ecode2 = 0 ;
26217 PyObject * obj0 = 0 ;
26218 PyObject * obj1 = 0 ;
26219 char * kwnames[] = {
26220 (char *) "pos",(char *) "winid", NULL
26221 };
26222
26223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26224 if (obj0) {
26225 {
26226 arg1 = &temp1;
26227 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26228 }
26229 }
26230 if (obj1) {
26231 ecode2 = SWIG_AsVal_int(obj1, &val2);
26232 if (!SWIG_IsOK(ecode2)) {
26233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26234 }
26235 arg2 = static_cast< int >(val2);
26236 }
26237 {
26238 PyThreadState* __tstate = wxPyBeginAllowThreads();
26239 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26240 wxPyEndAllowThreads(__tstate);
26241 if (PyErr_Occurred()) SWIG_fail;
26242 }
26243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26244 return resultobj;
26245 fail:
26246 return NULL;
26247 }
26248
26249
26250 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26251 PyObject *resultobj = 0;
26252 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26253 wxPoint result;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 PyObject *swig_obj[1] ;
26257
26258 if (!args) SWIG_fail;
26259 swig_obj[0] = args;
26260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26261 if (!SWIG_IsOK(res1)) {
26262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26263 }
26264 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 result = ((wxMoveEvent const *)arg1)->GetPosition();
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26279 PyObject *resultobj = 0;
26280 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26281 wxRect result;
26282 void *argp1 = 0 ;
26283 int res1 = 0 ;
26284 PyObject *swig_obj[1] ;
26285
26286 if (!args) SWIG_fail;
26287 swig_obj[0] = args;
26288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26289 if (!SWIG_IsOK(res1)) {
26290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26291 }
26292 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = ((wxMoveEvent const *)arg1)->GetRect();
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26300 return resultobj;
26301 fail:
26302 return NULL;
26303 }
26304
26305
26306 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj = 0;
26308 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26309 wxRect *arg2 = 0 ;
26310 void *argp1 = 0 ;
26311 int res1 = 0 ;
26312 wxRect temp2 ;
26313 PyObject * obj0 = 0 ;
26314 PyObject * obj1 = 0 ;
26315 char * kwnames[] = {
26316 (char *) "self",(char *) "rect", NULL
26317 };
26318
26319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26321 if (!SWIG_IsOK(res1)) {
26322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26323 }
26324 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26325 {
26326 arg2 = &temp2;
26327 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26328 }
26329 {
26330 PyThreadState* __tstate = wxPyBeginAllowThreads();
26331 (arg1)->SetRect((wxRect const &)*arg2);
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 resultobj = SWIG_Py_Void();
26336 return resultobj;
26337 fail:
26338 return NULL;
26339 }
26340
26341
26342 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26343 PyObject *resultobj = 0;
26344 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26345 wxPoint *arg2 = 0 ;
26346 void *argp1 = 0 ;
26347 int res1 = 0 ;
26348 wxPoint temp2 ;
26349 PyObject * obj0 = 0 ;
26350 PyObject * obj1 = 0 ;
26351 char * kwnames[] = {
26352 (char *) "self",(char *) "pos", NULL
26353 };
26354
26355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26357 if (!SWIG_IsOK(res1)) {
26358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26359 }
26360 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26361 {
26362 arg2 = &temp2;
26363 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26364 }
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 (arg1)->SetPosition((wxPoint const &)*arg2);
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 resultobj = SWIG_Py_Void();
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 PyObject *obj;
26380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26381 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26382 return SWIG_Py_Void();
26383 }
26384
26385 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26386 return SWIG_Python_InitShadowInstance(args);
26387 }
26388
26389 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26390 PyObject *resultobj = 0;
26391 int arg1 = (int) 0 ;
26392 wxPaintEvent *result = 0 ;
26393 int val1 ;
26394 int ecode1 = 0 ;
26395 PyObject * obj0 = 0 ;
26396 char * kwnames[] = {
26397 (char *) "Id", NULL
26398 };
26399
26400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26401 if (obj0) {
26402 ecode1 = SWIG_AsVal_int(obj0, &val1);
26403 if (!SWIG_IsOK(ecode1)) {
26404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26405 }
26406 arg1 = static_cast< int >(val1);
26407 }
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *obj;
26423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26424 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26425 return SWIG_Py_Void();
26426 }
26427
26428 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26429 return SWIG_Python_InitShadowInstance(args);
26430 }
26431
26432 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj = 0;
26434 int arg1 = (int) 0 ;
26435 wxNcPaintEvent *result = 0 ;
26436 int val1 ;
26437 int ecode1 = 0 ;
26438 PyObject * obj0 = 0 ;
26439 char * kwnames[] = {
26440 (char *) "winid", NULL
26441 };
26442
26443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26444 if (obj0) {
26445 ecode1 = SWIG_AsVal_int(obj0, &val1);
26446 if (!SWIG_IsOK(ecode1)) {
26447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26448 }
26449 arg1 = static_cast< int >(val1);
26450 }
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26465 PyObject *obj;
26466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26467 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26468 return SWIG_Py_Void();
26469 }
26470
26471 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26472 return SWIG_Python_InitShadowInstance(args);
26473 }
26474
26475 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26476 PyObject *resultobj = 0;
26477 int arg1 = (int) 0 ;
26478 wxDC *arg2 = (wxDC *) NULL ;
26479 wxEraseEvent *result = 0 ;
26480 int val1 ;
26481 int ecode1 = 0 ;
26482 void *argp2 = 0 ;
26483 int res2 = 0 ;
26484 PyObject * obj0 = 0 ;
26485 PyObject * obj1 = 0 ;
26486 char * kwnames[] = {
26487 (char *) "Id",(char *) "dc", NULL
26488 };
26489
26490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26491 if (obj0) {
26492 ecode1 = SWIG_AsVal_int(obj0, &val1);
26493 if (!SWIG_IsOK(ecode1)) {
26494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26495 }
26496 arg1 = static_cast< int >(val1);
26497 }
26498 if (obj1) {
26499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26500 if (!SWIG_IsOK(res2)) {
26501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26502 }
26503 arg2 = reinterpret_cast< wxDC * >(argp2);
26504 }
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26512 return resultobj;
26513 fail:
26514 return NULL;
26515 }
26516
26517
26518 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 PyObject *resultobj = 0;
26520 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26521 wxDC *result = 0 ;
26522 void *argp1 = 0 ;
26523 int res1 = 0 ;
26524 PyObject *swig_obj[1] ;
26525
26526 if (!args) SWIG_fail;
26527 swig_obj[0] = args;
26528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26529 if (!SWIG_IsOK(res1)) {
26530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26531 }
26532 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 {
26540 resultobj = wxPyMake_wxObject(result, (bool)0);
26541 }
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26549 PyObject *obj;
26550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26551 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26552 return SWIG_Py_Void();
26553 }
26554
26555 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26556 return SWIG_Python_InitShadowInstance(args);
26557 }
26558
26559 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj = 0;
26561 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26562 int arg2 = (int) 0 ;
26563 wxFocusEvent *result = 0 ;
26564 int val1 ;
26565 int ecode1 = 0 ;
26566 int val2 ;
26567 int ecode2 = 0 ;
26568 PyObject * obj0 = 0 ;
26569 PyObject * obj1 = 0 ;
26570 char * kwnames[] = {
26571 (char *) "type",(char *) "winid", NULL
26572 };
26573
26574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26575 if (obj0) {
26576 ecode1 = SWIG_AsVal_int(obj0, &val1);
26577 if (!SWIG_IsOK(ecode1)) {
26578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26579 }
26580 arg1 = static_cast< wxEventType >(val1);
26581 }
26582 if (obj1) {
26583 ecode2 = SWIG_AsVal_int(obj1, &val2);
26584 if (!SWIG_IsOK(ecode2)) {
26585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26586 }
26587 arg2 = static_cast< int >(val2);
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26603 PyObject *resultobj = 0;
26604 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26605 wxWindow *result = 0 ;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 PyObject *swig_obj[1] ;
26609
26610 if (!args) SWIG_fail;
26611 swig_obj[0] = args;
26612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26615 }
26616 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = wxPyMake_wxObject(result, (bool)0);
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26633 PyObject *resultobj = 0;
26634 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26635 wxWindow *arg2 = (wxWindow *) 0 ;
26636 void *argp1 = 0 ;
26637 int res1 = 0 ;
26638 void *argp2 = 0 ;
26639 int res2 = 0 ;
26640 PyObject * obj0 = 0 ;
26641 PyObject * obj1 = 0 ;
26642 char * kwnames[] = {
26643 (char *) "self",(char *) "win", NULL
26644 };
26645
26646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26648 if (!SWIG_IsOK(res1)) {
26649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26650 }
26651 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26653 if (!SWIG_IsOK(res2)) {
26654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26655 }
26656 arg2 = reinterpret_cast< wxWindow * >(argp2);
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 (arg1)->SetWindow(arg2);
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 resultobj = SWIG_Py_Void();
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26671 PyObject *obj;
26672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26673 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26674 return SWIG_Py_Void();
26675 }
26676
26677 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26678 return SWIG_Python_InitShadowInstance(args);
26679 }
26680
26681 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26682 PyObject *resultobj = 0;
26683 wxWindow *arg1 = (wxWindow *) NULL ;
26684 wxChildFocusEvent *result = 0 ;
26685 void *argp1 = 0 ;
26686 int res1 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 char * kwnames[] = {
26689 (char *) "win", NULL
26690 };
26691
26692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26693 if (obj0) {
26694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26695 if (!SWIG_IsOK(res1)) {
26696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26697 }
26698 arg1 = reinterpret_cast< wxWindow * >(argp1);
26699 }
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26703 wxPyEndAllowThreads(__tstate);
26704 if (PyErr_Occurred()) SWIG_fail;
26705 }
26706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26707 return resultobj;
26708 fail:
26709 return NULL;
26710 }
26711
26712
26713 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26714 PyObject *resultobj = 0;
26715 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26716 wxWindow *result = 0 ;
26717 void *argp1 = 0 ;
26718 int res1 = 0 ;
26719 PyObject *swig_obj[1] ;
26720
26721 if (!args) SWIG_fail;
26722 swig_obj[0] = args;
26723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26726 }
26727 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 {
26735 resultobj = wxPyMake_wxObject(result, (bool)0);
26736 }
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 PyObject *obj;
26745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26746 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26747 return SWIG_Py_Void();
26748 }
26749
26750 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751 return SWIG_Python_InitShadowInstance(args);
26752 }
26753
26754 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj = 0;
26756 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26757 bool arg2 = (bool) true ;
26758 int arg3 = (int) 0 ;
26759 wxActivateEvent *result = 0 ;
26760 int val1 ;
26761 int ecode1 = 0 ;
26762 bool val2 ;
26763 int ecode2 = 0 ;
26764 int val3 ;
26765 int ecode3 = 0 ;
26766 PyObject * obj0 = 0 ;
26767 PyObject * obj1 = 0 ;
26768 PyObject * obj2 = 0 ;
26769 char * kwnames[] = {
26770 (char *) "type",(char *) "active",(char *) "Id", NULL
26771 };
26772
26773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26774 if (obj0) {
26775 ecode1 = SWIG_AsVal_int(obj0, &val1);
26776 if (!SWIG_IsOK(ecode1)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26778 }
26779 arg1 = static_cast< wxEventType >(val1);
26780 }
26781 if (obj1) {
26782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26783 if (!SWIG_IsOK(ecode2)) {
26784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26785 }
26786 arg2 = static_cast< bool >(val2);
26787 }
26788 if (obj2) {
26789 ecode3 = SWIG_AsVal_int(obj2, &val3);
26790 if (!SWIG_IsOK(ecode3)) {
26791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26792 }
26793 arg3 = static_cast< int >(val3);
26794 }
26795 {
26796 PyThreadState* __tstate = wxPyBeginAllowThreads();
26797 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26809 PyObject *resultobj = 0;
26810 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26811 bool result;
26812 void *argp1 = 0 ;
26813 int res1 = 0 ;
26814 PyObject *swig_obj[1] ;
26815
26816 if (!args) SWIG_fail;
26817 swig_obj[0] = args;
26818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26819 if (!SWIG_IsOK(res1)) {
26820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26821 }
26822 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26823 {
26824 PyThreadState* __tstate = wxPyBeginAllowThreads();
26825 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 {
26830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26831 }
26832 return resultobj;
26833 fail:
26834 return NULL;
26835 }
26836
26837
26838 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26839 PyObject *obj;
26840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26841 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26842 return SWIG_Py_Void();
26843 }
26844
26845 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26846 return SWIG_Python_InitShadowInstance(args);
26847 }
26848
26849 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26850 PyObject *resultobj = 0;
26851 int arg1 = (int) 0 ;
26852 wxInitDialogEvent *result = 0 ;
26853 int val1 ;
26854 int ecode1 = 0 ;
26855 PyObject * obj0 = 0 ;
26856 char * kwnames[] = {
26857 (char *) "Id", NULL
26858 };
26859
26860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26861 if (obj0) {
26862 ecode1 = SWIG_AsVal_int(obj0, &val1);
26863 if (!SWIG_IsOK(ecode1)) {
26864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26865 }
26866 arg1 = static_cast< int >(val1);
26867 }
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26871 wxPyEndAllowThreads(__tstate);
26872 if (PyErr_Occurred()) SWIG_fail;
26873 }
26874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26875 return resultobj;
26876 fail:
26877 return NULL;
26878 }
26879
26880
26881 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26882 PyObject *obj;
26883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26884 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26885 return SWIG_Py_Void();
26886 }
26887
26888 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26889 return SWIG_Python_InitShadowInstance(args);
26890 }
26891
26892 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj = 0;
26894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26895 int arg2 = (int) 0 ;
26896 wxMenu *arg3 = (wxMenu *) NULL ;
26897 wxMenuEvent *result = 0 ;
26898 int val1 ;
26899 int ecode1 = 0 ;
26900 int val2 ;
26901 int ecode2 = 0 ;
26902 void *argp3 = 0 ;
26903 int res3 = 0 ;
26904 PyObject * obj0 = 0 ;
26905 PyObject * obj1 = 0 ;
26906 PyObject * obj2 = 0 ;
26907 char * kwnames[] = {
26908 (char *) "type",(char *) "winid",(char *) "menu", NULL
26909 };
26910
26911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26912 if (obj0) {
26913 ecode1 = SWIG_AsVal_int(obj0, &val1);
26914 if (!SWIG_IsOK(ecode1)) {
26915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26916 }
26917 arg1 = static_cast< wxEventType >(val1);
26918 }
26919 if (obj1) {
26920 ecode2 = SWIG_AsVal_int(obj1, &val2);
26921 if (!SWIG_IsOK(ecode2)) {
26922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26923 }
26924 arg2 = static_cast< int >(val2);
26925 }
26926 if (obj2) {
26927 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26928 if (!SWIG_IsOK(res3)) {
26929 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26930 }
26931 arg3 = reinterpret_cast< wxMenu * >(argp3);
26932 }
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26940 return resultobj;
26941 fail:
26942 return NULL;
26943 }
26944
26945
26946 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26947 PyObject *resultobj = 0;
26948 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26949 int result;
26950 void *argp1 = 0 ;
26951 int res1 = 0 ;
26952 PyObject *swig_obj[1] ;
26953
26954 if (!args) SWIG_fail;
26955 swig_obj[0] = args;
26956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26957 if (!SWIG_IsOK(res1)) {
26958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26959 }
26960 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26961 {
26962 PyThreadState* __tstate = wxPyBeginAllowThreads();
26963 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 resultobj = SWIG_From_int(static_cast< int >(result));
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26975 PyObject *resultobj = 0;
26976 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26977 bool result;
26978 void *argp1 = 0 ;
26979 int res1 = 0 ;
26980 PyObject *swig_obj[1] ;
26981
26982 if (!args) SWIG_fail;
26983 swig_obj[0] = args;
26984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26985 if (!SWIG_IsOK(res1)) {
26986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26987 }
26988 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 {
26996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26997 }
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27005 PyObject *resultobj = 0;
27006 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27007 wxMenu *result = 0 ;
27008 void *argp1 = 0 ;
27009 int res1 = 0 ;
27010 PyObject *swig_obj[1] ;
27011
27012 if (!args) SWIG_fail;
27013 swig_obj[0] = args;
27014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27015 if (!SWIG_IsOK(res1)) {
27016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27017 }
27018 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27019 {
27020 PyThreadState* __tstate = wxPyBeginAllowThreads();
27021 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 {
27026 resultobj = wxPyMake_wxObject(result, (bool)0);
27027 }
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27035 PyObject *obj;
27036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27037 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27038 return SWIG_Py_Void();
27039 }
27040
27041 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27042 return SWIG_Python_InitShadowInstance(args);
27043 }
27044
27045 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj = 0;
27047 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27048 int arg2 = (int) 0 ;
27049 wxCloseEvent *result = 0 ;
27050 int val1 ;
27051 int ecode1 = 0 ;
27052 int val2 ;
27053 int ecode2 = 0 ;
27054 PyObject * obj0 = 0 ;
27055 PyObject * obj1 = 0 ;
27056 char * kwnames[] = {
27057 (char *) "type",(char *) "winid", NULL
27058 };
27059
27060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27061 if (obj0) {
27062 ecode1 = SWIG_AsVal_int(obj0, &val1);
27063 if (!SWIG_IsOK(ecode1)) {
27064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27065 }
27066 arg1 = static_cast< wxEventType >(val1);
27067 }
27068 if (obj1) {
27069 ecode2 = SWIG_AsVal_int(obj1, &val2);
27070 if (!SWIG_IsOK(ecode2)) {
27071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27072 }
27073 arg2 = static_cast< int >(val2);
27074 }
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27078 wxPyEndAllowThreads(__tstate);
27079 if (PyErr_Occurred()) SWIG_fail;
27080 }
27081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj = 0;
27090 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27091 bool arg2 ;
27092 void *argp1 = 0 ;
27093 int res1 = 0 ;
27094 bool val2 ;
27095 int ecode2 = 0 ;
27096 PyObject * obj0 = 0 ;
27097 PyObject * obj1 = 0 ;
27098 char * kwnames[] = {
27099 (char *) "self",(char *) "logOff", NULL
27100 };
27101
27102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27104 if (!SWIG_IsOK(res1)) {
27105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27106 }
27107 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27109 if (!SWIG_IsOK(ecode2)) {
27110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27111 }
27112 arg2 = static_cast< bool >(val2);
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 (arg1)->SetLoggingOff(arg2);
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 resultobj = SWIG_Py_Void();
27120 return resultobj;
27121 fail:
27122 return NULL;
27123 }
27124
27125
27126 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27127 PyObject *resultobj = 0;
27128 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27129 bool result;
27130 void *argp1 = 0 ;
27131 int res1 = 0 ;
27132 PyObject *swig_obj[1] ;
27133
27134 if (!args) SWIG_fail;
27135 swig_obj[0] = args;
27136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27137 if (!SWIG_IsOK(res1)) {
27138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27139 }
27140 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27141 {
27142 PyThreadState* __tstate = wxPyBeginAllowThreads();
27143 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 {
27148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27149 }
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj = 0;
27158 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27159 bool arg2 = (bool) true ;
27160 void *argp1 = 0 ;
27161 int res1 = 0 ;
27162 bool val2 ;
27163 int ecode2 = 0 ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char * kwnames[] = {
27167 (char *) "self",(char *) "veto", NULL
27168 };
27169
27170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27172 if (!SWIG_IsOK(res1)) {
27173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27174 }
27175 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27176 if (obj1) {
27177 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27178 if (!SWIG_IsOK(ecode2)) {
27179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27180 }
27181 arg2 = static_cast< bool >(val2);
27182 }
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 (arg1)->Veto(arg2);
27186 wxPyEndAllowThreads(__tstate);
27187 if (PyErr_Occurred()) SWIG_fail;
27188 }
27189 resultobj = SWIG_Py_Void();
27190 return resultobj;
27191 fail:
27192 return NULL;
27193 }
27194
27195
27196 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27197 PyObject *resultobj = 0;
27198 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27199 bool result;
27200 void *argp1 = 0 ;
27201 int res1 = 0 ;
27202 PyObject *swig_obj[1] ;
27203
27204 if (!args) SWIG_fail;
27205 swig_obj[0] = args;
27206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27207 if (!SWIG_IsOK(res1)) {
27208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27209 }
27210 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27211 {
27212 PyThreadState* __tstate = wxPyBeginAllowThreads();
27213 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 {
27218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27219 }
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27227 PyObject *resultobj = 0;
27228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27229 bool arg2 ;
27230 void *argp1 = 0 ;
27231 int res1 = 0 ;
27232 bool val2 ;
27233 int ecode2 = 0 ;
27234 PyObject * obj0 = 0 ;
27235 PyObject * obj1 = 0 ;
27236 char * kwnames[] = {
27237 (char *) "self",(char *) "canVeto", NULL
27238 };
27239
27240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27242 if (!SWIG_IsOK(res1)) {
27243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27244 }
27245 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27247 if (!SWIG_IsOK(ecode2)) {
27248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27249 }
27250 arg2 = static_cast< bool >(val2);
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->SetCanVeto(arg2);
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 resultobj = SWIG_Py_Void();
27258 return resultobj;
27259 fail:
27260 return NULL;
27261 }
27262
27263
27264 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27265 PyObject *resultobj = 0;
27266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27267 bool result;
27268 void *argp1 = 0 ;
27269 int res1 = 0 ;
27270 PyObject *swig_obj[1] ;
27271
27272 if (!args) SWIG_fail;
27273 swig_obj[0] = args;
27274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27275 if (!SWIG_IsOK(res1)) {
27276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27277 }
27278 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27279 {
27280 PyThreadState* __tstate = wxPyBeginAllowThreads();
27281 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 {
27286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27287 }
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27295 PyObject *obj;
27296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27297 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27298 return SWIG_Py_Void();
27299 }
27300
27301 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27302 return SWIG_Python_InitShadowInstance(args);
27303 }
27304
27305 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27306 PyObject *resultobj = 0;
27307 int arg1 = (int) 0 ;
27308 bool arg2 = (bool) false ;
27309 wxShowEvent *result = 0 ;
27310 int val1 ;
27311 int ecode1 = 0 ;
27312 bool val2 ;
27313 int ecode2 = 0 ;
27314 PyObject * obj0 = 0 ;
27315 PyObject * obj1 = 0 ;
27316 char * kwnames[] = {
27317 (char *) "winid",(char *) "show", NULL
27318 };
27319
27320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27321 if (obj0) {
27322 ecode1 = SWIG_AsVal_int(obj0, &val1);
27323 if (!SWIG_IsOK(ecode1)) {
27324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27325 }
27326 arg1 = static_cast< int >(val1);
27327 }
27328 if (obj1) {
27329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27330 if (!SWIG_IsOK(ecode2)) {
27331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27332 }
27333 arg2 = static_cast< bool >(val2);
27334 }
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj = 0;
27350 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27351 bool arg2 ;
27352 void *argp1 = 0 ;
27353 int res1 = 0 ;
27354 bool val2 ;
27355 int ecode2 = 0 ;
27356 PyObject * obj0 = 0 ;
27357 PyObject * obj1 = 0 ;
27358 char * kwnames[] = {
27359 (char *) "self",(char *) "show", NULL
27360 };
27361
27362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27364 if (!SWIG_IsOK(res1)) {
27365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27366 }
27367 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27369 if (!SWIG_IsOK(ecode2)) {
27370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27371 }
27372 arg2 = static_cast< bool >(val2);
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 (arg1)->SetShow(arg2);
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 resultobj = SWIG_Py_Void();
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27387 PyObject *resultobj = 0;
27388 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27389 bool result;
27390 void *argp1 = 0 ;
27391 int res1 = 0 ;
27392 PyObject *swig_obj[1] ;
27393
27394 if (!args) SWIG_fail;
27395 swig_obj[0] = args;
27396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27397 if (!SWIG_IsOK(res1)) {
27398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27399 }
27400 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27404 wxPyEndAllowThreads(__tstate);
27405 if (PyErr_Occurred()) SWIG_fail;
27406 }
27407 {
27408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27409 }
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27417 PyObject *obj;
27418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27419 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27420 return SWIG_Py_Void();
27421 }
27422
27423 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27424 return SWIG_Python_InitShadowInstance(args);
27425 }
27426
27427 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27428 PyObject *resultobj = 0;
27429 int arg1 = (int) 0 ;
27430 bool arg2 = (bool) true ;
27431 wxIconizeEvent *result = 0 ;
27432 int val1 ;
27433 int ecode1 = 0 ;
27434 bool val2 ;
27435 int ecode2 = 0 ;
27436 PyObject * obj0 = 0 ;
27437 PyObject * obj1 = 0 ;
27438 char * kwnames[] = {
27439 (char *) "id",(char *) "iconized", NULL
27440 };
27441
27442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27443 if (obj0) {
27444 ecode1 = SWIG_AsVal_int(obj0, &val1);
27445 if (!SWIG_IsOK(ecode1)) {
27446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27447 }
27448 arg1 = static_cast< int >(val1);
27449 }
27450 if (obj1) {
27451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27452 if (!SWIG_IsOK(ecode2)) {
27453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27454 }
27455 arg2 = static_cast< bool >(val2);
27456 }
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27473 bool result;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 PyObject *swig_obj[1] ;
27477
27478 if (!args) SWIG_fail;
27479 swig_obj[0] = args;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27483 }
27484 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)(arg1)->Iconized();
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 {
27492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27493 }
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *obj;
27502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27503 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27504 return SWIG_Py_Void();
27505 }
27506
27507 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27508 return SWIG_Python_InitShadowInstance(args);
27509 }
27510
27511 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 int arg1 = (int) 0 ;
27514 wxMaximizeEvent *result = 0 ;
27515 int val1 ;
27516 int ecode1 = 0 ;
27517 PyObject * obj0 = 0 ;
27518 char * kwnames[] = {
27519 (char *) "id", NULL
27520 };
27521
27522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27523 if (obj0) {
27524 ecode1 = SWIG_AsVal_int(obj0, &val1);
27525 if (!SWIG_IsOK(ecode1)) {
27526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27527 }
27528 arg1 = static_cast< int >(val1);
27529 }
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27537 return resultobj;
27538 fail:
27539 return NULL;
27540 }
27541
27542
27543 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27544 PyObject *obj;
27545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27546 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27547 return SWIG_Py_Void();
27548 }
27549
27550 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27551 return SWIG_Python_InitShadowInstance(args);
27552 }
27553
27554 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27555 PyObject *resultobj = 0;
27556 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27557 wxPoint result;
27558 void *argp1 = 0 ;
27559 int res1 = 0 ;
27560 PyObject *swig_obj[1] ;
27561
27562 if (!args) SWIG_fail;
27563 swig_obj[0] = args;
27564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27565 if (!SWIG_IsOK(res1)) {
27566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27567 }
27568 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (arg1)->GetPosition();
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27583 PyObject *resultobj = 0;
27584 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27585 int result;
27586 void *argp1 = 0 ;
27587 int res1 = 0 ;
27588 PyObject *swig_obj[1] ;
27589
27590 if (!args) SWIG_fail;
27591 swig_obj[0] = args;
27592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27593 if (!SWIG_IsOK(res1)) {
27594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27595 }
27596 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (int)(arg1)->GetNumberOfFiles();
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 resultobj = SWIG_From_int(static_cast< int >(result));
27604 return resultobj;
27605 fail:
27606 return NULL;
27607 }
27608
27609
27610 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27611 PyObject *resultobj = 0;
27612 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27613 PyObject *result = 0 ;
27614 void *argp1 = 0 ;
27615 int res1 = 0 ;
27616 PyObject *swig_obj[1] ;
27617
27618 if (!args) SWIG_fail;
27619 swig_obj[0] = args;
27620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27621 if (!SWIG_IsOK(res1)) {
27622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27623 }
27624 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27625 {
27626 PyThreadState* __tstate = wxPyBeginAllowThreads();
27627 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 resultobj = result;
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639 PyObject *obj;
27640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27641 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27642 return SWIG_Py_Void();
27643 }
27644
27645 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27646 PyObject *resultobj = 0;
27647 int arg1 = (int) 0 ;
27648 wxUpdateUIEvent *result = 0 ;
27649 int val1 ;
27650 int ecode1 = 0 ;
27651 PyObject * obj0 = 0 ;
27652 char * kwnames[] = {
27653 (char *) "commandId", NULL
27654 };
27655
27656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27657 if (obj0) {
27658 ecode1 = SWIG_AsVal_int(obj0, &val1);
27659 if (!SWIG_IsOK(ecode1)) {
27660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27661 }
27662 arg1 = static_cast< int >(val1);
27663 }
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27678 PyObject *resultobj = 0;
27679 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27680 bool result;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 PyObject *swig_obj[1] ;
27684
27685 if (!args) SWIG_fail;
27686 swig_obj[0] = args;
27687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27688 if (!SWIG_IsOK(res1)) {
27689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27690 }
27691 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27692 {
27693 PyThreadState* __tstate = wxPyBeginAllowThreads();
27694 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27695 wxPyEndAllowThreads(__tstate);
27696 if (PyErr_Occurred()) SWIG_fail;
27697 }
27698 {
27699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27700 }
27701 return resultobj;
27702 fail:
27703 return NULL;
27704 }
27705
27706
27707 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27708 PyObject *resultobj = 0;
27709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27710 bool result;
27711 void *argp1 = 0 ;
27712 int res1 = 0 ;
27713 PyObject *swig_obj[1] ;
27714
27715 if (!args) SWIG_fail;
27716 swig_obj[0] = args;
27717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27718 if (!SWIG_IsOK(res1)) {
27719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27720 }
27721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27725 wxPyEndAllowThreads(__tstate);
27726 if (PyErr_Occurred()) SWIG_fail;
27727 }
27728 {
27729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27730 }
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27738 PyObject *resultobj = 0;
27739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27740 bool result;
27741 void *argp1 = 0 ;
27742 int res1 = 0 ;
27743 PyObject *swig_obj[1] ;
27744
27745 if (!args) SWIG_fail;
27746 swig_obj[0] = args;
27747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27748 if (!SWIG_IsOK(res1)) {
27749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27750 }
27751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 {
27759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27760 }
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27770 wxString result;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 PyObject *swig_obj[1] ;
27774
27775 if (!args) SWIG_fail;
27776 swig_obj[0] = args;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27780 }
27781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 {
27789 #if wxUSE_UNICODE
27790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27791 #else
27792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27793 #endif
27794 }
27795 return resultobj;
27796 fail:
27797 return NULL;
27798 }
27799
27800
27801 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27802 PyObject *resultobj = 0;
27803 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27804 bool result;
27805 void *argp1 = 0 ;
27806 int res1 = 0 ;
27807 PyObject *swig_obj[1] ;
27808
27809 if (!args) SWIG_fail;
27810 swig_obj[0] = args;
27811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27812 if (!SWIG_IsOK(res1)) {
27813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27814 }
27815 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 {
27823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27824 }
27825 return resultobj;
27826 fail:
27827 return NULL;
27828 }
27829
27830
27831 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27832 PyObject *resultobj = 0;
27833 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27834 bool result;
27835 void *argp1 = 0 ;
27836 int res1 = 0 ;
27837 PyObject *swig_obj[1] ;
27838
27839 if (!args) SWIG_fail;
27840 swig_obj[0] = args;
27841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27842 if (!SWIG_IsOK(res1)) {
27843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27844 }
27845 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 {
27853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27854 }
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27862 PyObject *resultobj = 0;
27863 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27864 bool result;
27865 void *argp1 = 0 ;
27866 int res1 = 0 ;
27867 PyObject *swig_obj[1] ;
27868
27869 if (!args) SWIG_fail;
27870 swig_obj[0] = args;
27871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27872 if (!SWIG_IsOK(res1)) {
27873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27874 }
27875 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 {
27883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27884 }
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27892 PyObject *resultobj = 0;
27893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27894 bool result;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 PyObject *swig_obj[1] ;
27898
27899 if (!args) SWIG_fail;
27900 swig_obj[0] = args;
27901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27902 if (!SWIG_IsOK(res1)) {
27903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27904 }
27905 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27914 }
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj = 0;
27923 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27924 bool arg2 ;
27925 void *argp1 = 0 ;
27926 int res1 = 0 ;
27927 bool val2 ;
27928 int ecode2 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "self",(char *) "check", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27939 }
27940 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27942 if (!SWIG_IsOK(ecode2)) {
27943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27944 }
27945 arg2 = static_cast< bool >(val2);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 (arg1)->Check(arg2);
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 resultobj = SWIG_Py_Void();
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj = 0;
27961 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27962 bool arg2 ;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 bool val2 ;
27966 int ecode2 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 PyObject * obj1 = 0 ;
27969 char * kwnames[] = {
27970 (char *) "self",(char *) "enable", NULL
27971 };
27972
27973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27975 if (!SWIG_IsOK(res1)) {
27976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27977 }
27978 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27980 if (!SWIG_IsOK(ecode2)) {
27981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27982 }
27983 arg2 = static_cast< bool >(val2);
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 (arg1)->Enable(arg2);
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 resultobj = SWIG_Py_Void();
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj = 0;
27999 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28000 bool arg2 ;
28001 void *argp1 = 0 ;
28002 int res1 = 0 ;
28003 bool val2 ;
28004 int ecode2 = 0 ;
28005 PyObject * obj0 = 0 ;
28006 PyObject * obj1 = 0 ;
28007 char * kwnames[] = {
28008 (char *) "self",(char *) "show", NULL
28009 };
28010
28011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28015 }
28016 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28017 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28018 if (!SWIG_IsOK(ecode2)) {
28019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28020 }
28021 arg2 = static_cast< bool >(val2);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 (arg1)->Show(arg2);
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 resultobj = SWIG_Py_Void();
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj = 0;
28037 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28038 wxString *arg2 = 0 ;
28039 void *argp1 = 0 ;
28040 int res1 = 0 ;
28041 bool temp2 = false ;
28042 PyObject * obj0 = 0 ;
28043 PyObject * obj1 = 0 ;
28044 char * kwnames[] = {
28045 (char *) "self",(char *) "text", NULL
28046 };
28047
28048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28050 if (!SWIG_IsOK(res1)) {
28051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28052 }
28053 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28054 {
28055 arg2 = wxString_in_helper(obj1);
28056 if (arg2 == NULL) SWIG_fail;
28057 temp2 = true;
28058 }
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 (arg1)->SetText((wxString const &)*arg2);
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_Py_Void();
28066 {
28067 if (temp2)
28068 delete arg2;
28069 }
28070 return resultobj;
28071 fail:
28072 {
28073 if (temp2)
28074 delete arg2;
28075 }
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 long arg1 ;
28083 long val1 ;
28084 int ecode1 = 0 ;
28085 PyObject * obj0 = 0 ;
28086 char * kwnames[] = {
28087 (char *) "updateInterval", NULL
28088 };
28089
28090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28091 ecode1 = SWIG_AsVal_long(obj0, &val1);
28092 if (!SWIG_IsOK(ecode1)) {
28093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28094 }
28095 arg1 = static_cast< long >(val1);
28096 {
28097 PyThreadState* __tstate = wxPyBeginAllowThreads();
28098 wxUpdateUIEvent::SetUpdateInterval(arg1);
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 resultobj = SWIG_Py_Void();
28103 return resultobj;
28104 fail:
28105 return NULL;
28106 }
28107
28108
28109 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28110 PyObject *resultobj = 0;
28111 long result;
28112
28113 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28114 {
28115 PyThreadState* __tstate = wxPyBeginAllowThreads();
28116 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28117 wxPyEndAllowThreads(__tstate);
28118 if (PyErr_Occurred()) SWIG_fail;
28119 }
28120 resultobj = SWIG_From_long(static_cast< long >(result));
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj = 0;
28129 wxWindow *arg1 = (wxWindow *) 0 ;
28130 bool result;
28131 void *argp1 = 0 ;
28132 int res1 = 0 ;
28133 PyObject * obj0 = 0 ;
28134 char * kwnames[] = {
28135 (char *) "win", NULL
28136 };
28137
28138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28140 if (!SWIG_IsOK(res1)) {
28141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28142 }
28143 arg1 = reinterpret_cast< wxWindow * >(argp1);
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 {
28151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28152 }
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *resultobj = 0;
28161
28162 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 wxUpdateUIEvent::ResetUpdateTime();
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_Py_Void();
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 wxUpdateUIMode arg1 ;
28179 int val1 ;
28180 int ecode1 = 0 ;
28181 PyObject * obj0 = 0 ;
28182 char * kwnames[] = {
28183 (char *) "mode", NULL
28184 };
28185
28186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28187 ecode1 = SWIG_AsVal_int(obj0, &val1);
28188 if (!SWIG_IsOK(ecode1)) {
28189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28190 }
28191 arg1 = static_cast< wxUpdateUIMode >(val1);
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 wxUpdateUIEvent::SetMode(arg1);
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 resultobj = SWIG_Py_Void();
28199 return resultobj;
28200 fail:
28201 return NULL;
28202 }
28203
28204
28205 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28206 PyObject *resultobj = 0;
28207 wxUpdateUIMode result;
28208
28209 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_From_int(static_cast< int >(result));
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28224 PyObject *obj;
28225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28226 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28227 return SWIG_Py_Void();
28228 }
28229
28230 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28231 return SWIG_Python_InitShadowInstance(args);
28232 }
28233
28234 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28235 PyObject *resultobj = 0;
28236 wxSysColourChangedEvent *result = 0 ;
28237
28238 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28253 PyObject *obj;
28254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28255 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28256 return SWIG_Py_Void();
28257 }
28258
28259 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 return SWIG_Python_InitShadowInstance(args);
28261 }
28262
28263 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj = 0;
28265 int arg1 = (int) 0 ;
28266 wxWindow *arg2 = (wxWindow *) NULL ;
28267 wxMouseCaptureChangedEvent *result = 0 ;
28268 int val1 ;
28269 int ecode1 = 0 ;
28270 void *argp2 = 0 ;
28271 int res2 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 char * kwnames[] = {
28275 (char *) "winid",(char *) "gainedCapture", NULL
28276 };
28277
28278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28279 if (obj0) {
28280 ecode1 = SWIG_AsVal_int(obj0, &val1);
28281 if (!SWIG_IsOK(ecode1)) {
28282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28283 }
28284 arg1 = static_cast< int >(val1);
28285 }
28286 if (obj1) {
28287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28288 if (!SWIG_IsOK(res2)) {
28289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28290 }
28291 arg2 = reinterpret_cast< wxWindow * >(argp2);
28292 }
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28309 wxWindow *result = 0 ;
28310 void *argp1 = 0 ;
28311 int res1 = 0 ;
28312 PyObject *swig_obj[1] ;
28313
28314 if (!args) SWIG_fail;
28315 swig_obj[0] = args;
28316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28317 if (!SWIG_IsOK(res1)) {
28318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28319 }
28320 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28321 {
28322 PyThreadState* __tstate = wxPyBeginAllowThreads();
28323 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28324 wxPyEndAllowThreads(__tstate);
28325 if (PyErr_Occurred()) SWIG_fail;
28326 }
28327 {
28328 resultobj = wxPyMake_wxObject(result, (bool)0);
28329 }
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *obj;
28338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28339 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28340 return SWIG_Py_Void();
28341 }
28342
28343 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 return SWIG_Python_InitShadowInstance(args);
28345 }
28346
28347 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj = 0;
28349 int arg1 = (int) 0 ;
28350 wxMouseCaptureLostEvent *result = 0 ;
28351 int val1 ;
28352 int ecode1 = 0 ;
28353 PyObject * obj0 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "winid", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28359 if (obj0) {
28360 ecode1 = SWIG_AsVal_int(obj0, &val1);
28361 if (!SWIG_IsOK(ecode1)) {
28362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28363 }
28364 arg1 = static_cast< int >(val1);
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28380 PyObject *obj;
28381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28382 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28383 return SWIG_Py_Void();
28384 }
28385
28386 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28387 return SWIG_Python_InitShadowInstance(args);
28388 }
28389
28390 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28391 PyObject *resultobj = 0;
28392 wxDisplayChangedEvent *result = 0 ;
28393
28394 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28395 {
28396 PyThreadState* __tstate = wxPyBeginAllowThreads();
28397 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28402 return resultobj;
28403 fail:
28404 return NULL;
28405 }
28406
28407
28408 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28409 PyObject *obj;
28410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28411 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28412 return SWIG_Py_Void();
28413 }
28414
28415 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28416 return SWIG_Python_InitShadowInstance(args);
28417 }
28418
28419 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj = 0;
28421 int arg1 = (int) 0 ;
28422 wxPaletteChangedEvent *result = 0 ;
28423 int val1 ;
28424 int ecode1 = 0 ;
28425 PyObject * obj0 = 0 ;
28426 char * kwnames[] = {
28427 (char *) "id", NULL
28428 };
28429
28430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28431 if (obj0) {
28432 ecode1 = SWIG_AsVal_int(obj0, &val1);
28433 if (!SWIG_IsOK(ecode1)) {
28434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28435 }
28436 arg1 = static_cast< int >(val1);
28437 }
28438 {
28439 PyThreadState* __tstate = wxPyBeginAllowThreads();
28440 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28441 wxPyEndAllowThreads(__tstate);
28442 if (PyErr_Occurred()) SWIG_fail;
28443 }
28444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28445 return resultobj;
28446 fail:
28447 return NULL;
28448 }
28449
28450
28451 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj = 0;
28453 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28454 wxWindow *arg2 = (wxWindow *) 0 ;
28455 void *argp1 = 0 ;
28456 int res1 = 0 ;
28457 void *argp2 = 0 ;
28458 int res2 = 0 ;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char * kwnames[] = {
28462 (char *) "self",(char *) "win", NULL
28463 };
28464
28465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28467 if (!SWIG_IsOK(res1)) {
28468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28469 }
28470 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28472 if (!SWIG_IsOK(res2)) {
28473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28474 }
28475 arg2 = reinterpret_cast< wxWindow * >(argp2);
28476 {
28477 PyThreadState* __tstate = wxPyBeginAllowThreads();
28478 (arg1)->SetChangedWindow(arg2);
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 resultobj = SWIG_Py_Void();
28483 return resultobj;
28484 fail:
28485 return NULL;
28486 }
28487
28488
28489 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28490 PyObject *resultobj = 0;
28491 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28492 wxWindow *result = 0 ;
28493 void *argp1 = 0 ;
28494 int res1 = 0 ;
28495 PyObject *swig_obj[1] ;
28496
28497 if (!args) SWIG_fail;
28498 swig_obj[0] = args;
28499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28500 if (!SWIG_IsOK(res1)) {
28501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28502 }
28503 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (wxWindow *)(arg1)->GetChangedWindow();
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = wxPyMake_wxObject(result, (bool)0);
28512 }
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28520 PyObject *obj;
28521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28522 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28523 return SWIG_Py_Void();
28524 }
28525
28526 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28527 return SWIG_Python_InitShadowInstance(args);
28528 }
28529
28530 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj = 0;
28532 int arg1 = (int) 0 ;
28533 wxQueryNewPaletteEvent *result = 0 ;
28534 int val1 ;
28535 int ecode1 = 0 ;
28536 PyObject * obj0 = 0 ;
28537 char * kwnames[] = {
28538 (char *) "winid", NULL
28539 };
28540
28541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28542 if (obj0) {
28543 ecode1 = SWIG_AsVal_int(obj0, &val1);
28544 if (!SWIG_IsOK(ecode1)) {
28545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28546 }
28547 arg1 = static_cast< int >(val1);
28548 }
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj = 0;
28564 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28565 bool arg2 ;
28566 void *argp1 = 0 ;
28567 int res1 = 0 ;
28568 bool val2 ;
28569 int ecode2 = 0 ;
28570 PyObject * obj0 = 0 ;
28571 PyObject * obj1 = 0 ;
28572 char * kwnames[] = {
28573 (char *) "self",(char *) "realized", NULL
28574 };
28575
28576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28578 if (!SWIG_IsOK(res1)) {
28579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28580 }
28581 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28582 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28583 if (!SWIG_IsOK(ecode2)) {
28584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28585 }
28586 arg2 = static_cast< bool >(val2);
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 (arg1)->SetPaletteRealized(arg2);
28590 wxPyEndAllowThreads(__tstate);
28591 if (PyErr_Occurred()) SWIG_fail;
28592 }
28593 resultobj = SWIG_Py_Void();
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28601 PyObject *resultobj = 0;
28602 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28603 bool result;
28604 void *argp1 = 0 ;
28605 int res1 = 0 ;
28606 PyObject *swig_obj[1] ;
28607
28608 if (!args) SWIG_fail;
28609 swig_obj[0] = args;
28610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28611 if (!SWIG_IsOK(res1)) {
28612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28613 }
28614 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 {
28622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28623 }
28624 return resultobj;
28625 fail:
28626 return NULL;
28627 }
28628
28629
28630 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28631 PyObject *obj;
28632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28633 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28634 return SWIG_Py_Void();
28635 }
28636
28637 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28638 return SWIG_Python_InitShadowInstance(args);
28639 }
28640
28641 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642 PyObject *resultobj = 0;
28643 wxNavigationKeyEvent *result = 0 ;
28644
28645 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28653 return resultobj;
28654 fail:
28655 return NULL;
28656 }
28657
28658
28659 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28660 PyObject *resultobj = 0;
28661 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28662 bool result;
28663 void *argp1 = 0 ;
28664 int res1 = 0 ;
28665 PyObject *swig_obj[1] ;
28666
28667 if (!args) SWIG_fail;
28668 swig_obj[0] = args;
28669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28670 if (!SWIG_IsOK(res1)) {
28671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28672 }
28673 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 {
28681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28682 }
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj = 0;
28691 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28692 bool arg2 ;
28693 void *argp1 = 0 ;
28694 int res1 = 0 ;
28695 bool val2 ;
28696 int ecode2 = 0 ;
28697 PyObject * obj0 = 0 ;
28698 PyObject * obj1 = 0 ;
28699 char * kwnames[] = {
28700 (char *) "self",(char *) "forward", NULL
28701 };
28702
28703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28705 if (!SWIG_IsOK(res1)) {
28706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28707 }
28708 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28710 if (!SWIG_IsOK(ecode2)) {
28711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28712 }
28713 arg2 = static_cast< bool >(val2);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 (arg1)->SetDirection(arg2);
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 resultobj = SWIG_Py_Void();
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28728 PyObject *resultobj = 0;
28729 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28730 bool result;
28731 void *argp1 = 0 ;
28732 int res1 = 0 ;
28733 PyObject *swig_obj[1] ;
28734
28735 if (!args) SWIG_fail;
28736 swig_obj[0] = args;
28737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28738 if (!SWIG_IsOK(res1)) {
28739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28740 }
28741 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 {
28749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28750 }
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj = 0;
28759 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28760 bool arg2 ;
28761 void *argp1 = 0 ;
28762 int res1 = 0 ;
28763 bool val2 ;
28764 int ecode2 = 0 ;
28765 PyObject * obj0 = 0 ;
28766 PyObject * obj1 = 0 ;
28767 char * kwnames[] = {
28768 (char *) "self",(char *) "ischange", NULL
28769 };
28770
28771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28773 if (!SWIG_IsOK(res1)) {
28774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28775 }
28776 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28778 if (!SWIG_IsOK(ecode2)) {
28779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28780 }
28781 arg2 = static_cast< bool >(val2);
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 (arg1)->SetWindowChange(arg2);
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_Py_Void();
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28796 PyObject *resultobj = 0;
28797 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28798 bool result;
28799 void *argp1 = 0 ;
28800 int res1 = 0 ;
28801 PyObject *swig_obj[1] ;
28802
28803 if (!args) SWIG_fail;
28804 swig_obj[0] = args;
28805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28808 }
28809 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 {
28817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28818 }
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28826 PyObject *resultobj = 0;
28827 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28828 bool arg2 ;
28829 void *argp1 = 0 ;
28830 int res1 = 0 ;
28831 bool val2 ;
28832 int ecode2 = 0 ;
28833 PyObject * obj0 = 0 ;
28834 PyObject * obj1 = 0 ;
28835 char * kwnames[] = {
28836 (char *) "self",(char *) "bIs", NULL
28837 };
28838
28839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28841 if (!SWIG_IsOK(res1)) {
28842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28843 }
28844 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28846 if (!SWIG_IsOK(ecode2)) {
28847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28848 }
28849 arg2 = static_cast< bool >(val2);
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 (arg1)->SetFromTab(arg2);
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 resultobj = SWIG_Py_Void();
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj = 0;
28865 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28866 long arg2 ;
28867 void *argp1 = 0 ;
28868 int res1 = 0 ;
28869 long val2 ;
28870 int ecode2 = 0 ;
28871 PyObject * obj0 = 0 ;
28872 PyObject * obj1 = 0 ;
28873 char * kwnames[] = {
28874 (char *) "self",(char *) "flags", NULL
28875 };
28876
28877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28879 if (!SWIG_IsOK(res1)) {
28880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28881 }
28882 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28883 ecode2 = SWIG_AsVal_long(obj1, &val2);
28884 if (!SWIG_IsOK(ecode2)) {
28885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28886 }
28887 arg2 = static_cast< long >(val2);
28888 {
28889 PyThreadState* __tstate = wxPyBeginAllowThreads();
28890 (arg1)->SetFlags(arg2);
28891 wxPyEndAllowThreads(__tstate);
28892 if (PyErr_Occurred()) SWIG_fail;
28893 }
28894 resultobj = SWIG_Py_Void();
28895 return resultobj;
28896 fail:
28897 return NULL;
28898 }
28899
28900
28901 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28902 PyObject *resultobj = 0;
28903 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28904 wxWindow *result = 0 ;
28905 void *argp1 = 0 ;
28906 int res1 = 0 ;
28907 PyObject *swig_obj[1] ;
28908
28909 if (!args) SWIG_fail;
28910 swig_obj[0] = args;
28911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28912 if (!SWIG_IsOK(res1)) {
28913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28914 }
28915 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28916 {
28917 PyThreadState* __tstate = wxPyBeginAllowThreads();
28918 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28919 wxPyEndAllowThreads(__tstate);
28920 if (PyErr_Occurred()) SWIG_fail;
28921 }
28922 {
28923 resultobj = wxPyMake_wxObject(result, (bool)0);
28924 }
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj = 0;
28933 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28934 wxWindow *arg2 = (wxWindow *) 0 ;
28935 void *argp1 = 0 ;
28936 int res1 = 0 ;
28937 void *argp2 = 0 ;
28938 int res2 = 0 ;
28939 PyObject * obj0 = 0 ;
28940 PyObject * obj1 = 0 ;
28941 char * kwnames[] = {
28942 (char *) "self",(char *) "win", NULL
28943 };
28944
28945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28947 if (!SWIG_IsOK(res1)) {
28948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28949 }
28950 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28952 if (!SWIG_IsOK(res2)) {
28953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28954 }
28955 arg2 = reinterpret_cast< wxWindow * >(argp2);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 (arg1)->SetCurrentFocus(arg2);
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *obj;
28971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28972 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28973 return SWIG_Py_Void();
28974 }
28975
28976 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28977 return SWIG_Python_InitShadowInstance(args);
28978 }
28979
28980 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 wxWindow *arg1 = (wxWindow *) NULL ;
28983 wxWindowCreateEvent *result = 0 ;
28984 void *argp1 = 0 ;
28985 int res1 = 0 ;
28986 PyObject * obj0 = 0 ;
28987 char * kwnames[] = {
28988 (char *) "win", NULL
28989 };
28990
28991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28992 if (obj0) {
28993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28994 if (!SWIG_IsOK(res1)) {
28995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28996 }
28997 arg1 = reinterpret_cast< wxWindow * >(argp1);
28998 }
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29006 return resultobj;
29007 fail:
29008 return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013 PyObject *resultobj = 0;
29014 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29015 wxWindow *result = 0 ;
29016 void *argp1 = 0 ;
29017 int res1 = 0 ;
29018 PyObject *swig_obj[1] ;
29019
29020 if (!args) SWIG_fail;
29021 swig_obj[0] = args;
29022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29023 if (!SWIG_IsOK(res1)) {
29024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29025 }
29026 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29027 {
29028 PyThreadState* __tstate = wxPyBeginAllowThreads();
29029 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29030 wxPyEndAllowThreads(__tstate);
29031 if (PyErr_Occurred()) SWIG_fail;
29032 }
29033 {
29034 resultobj = wxPyMake_wxObject(result, (bool)0);
29035 }
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29043 PyObject *obj;
29044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29045 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29046 return SWIG_Py_Void();
29047 }
29048
29049 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29050 return SWIG_Python_InitShadowInstance(args);
29051 }
29052
29053 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29054 PyObject *resultobj = 0;
29055 wxWindow *arg1 = (wxWindow *) NULL ;
29056 wxWindowDestroyEvent *result = 0 ;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 PyObject * obj0 = 0 ;
29060 char * kwnames[] = {
29061 (char *) "win", NULL
29062 };
29063
29064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29065 if (obj0) {
29066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29067 if (!SWIG_IsOK(res1)) {
29068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29069 }
29070 arg1 = reinterpret_cast< wxWindow * >(argp1);
29071 }
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29079 return resultobj;
29080 fail:
29081 return NULL;
29082 }
29083
29084
29085 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29086 PyObject *resultobj = 0;
29087 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29088 wxWindow *result = 0 ;
29089 void *argp1 = 0 ;
29090 int res1 = 0 ;
29091 PyObject *swig_obj[1] ;
29092
29093 if (!args) SWIG_fail;
29094 swig_obj[0] = args;
29095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29096 if (!SWIG_IsOK(res1)) {
29097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29098 }
29099 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 {
29107 resultobj = wxPyMake_wxObject(result, (bool)0);
29108 }
29109 return resultobj;
29110 fail:
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 PyObject *obj;
29117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29118 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29119 return SWIG_Py_Void();
29120 }
29121
29122 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29123 return SWIG_Python_InitShadowInstance(args);
29124 }
29125
29126 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj = 0;
29128 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29129 int arg2 = (int) 0 ;
29130 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29131 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29132 wxContextMenuEvent *result = 0 ;
29133 int val1 ;
29134 int ecode1 = 0 ;
29135 int val2 ;
29136 int ecode2 = 0 ;
29137 wxPoint temp3 ;
29138 PyObject * obj0 = 0 ;
29139 PyObject * obj1 = 0 ;
29140 PyObject * obj2 = 0 ;
29141 char * kwnames[] = {
29142 (char *) "type",(char *) "winid",(char *) "pt", NULL
29143 };
29144
29145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29146 if (obj0) {
29147 ecode1 = SWIG_AsVal_int(obj0, &val1);
29148 if (!SWIG_IsOK(ecode1)) {
29149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29150 }
29151 arg1 = static_cast< wxEventType >(val1);
29152 }
29153 if (obj1) {
29154 ecode2 = SWIG_AsVal_int(obj1, &val2);
29155 if (!SWIG_IsOK(ecode2)) {
29156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29157 }
29158 arg2 = static_cast< int >(val2);
29159 }
29160 if (obj2) {
29161 {
29162 arg3 = &temp3;
29163 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29164 }
29165 }
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29180 PyObject *resultobj = 0;
29181 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29182 wxPoint *result = 0 ;
29183 void *argp1 = 0 ;
29184 int res1 = 0 ;
29185 PyObject *swig_obj[1] ;
29186
29187 if (!args) SWIG_fail;
29188 swig_obj[0] = args;
29189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29192 }
29193 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 {
29197 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29198 result = (wxPoint *) &_result_ref;
29199 }
29200 wxPyEndAllowThreads(__tstate);
29201 if (PyErr_Occurred()) SWIG_fail;
29202 }
29203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj = 0;
29212 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29213 wxPoint *arg2 = 0 ;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 wxPoint temp2 ;
29217 PyObject * obj0 = 0 ;
29218 PyObject * obj1 = 0 ;
29219 char * kwnames[] = {
29220 (char *) "self",(char *) "pos", NULL
29221 };
29222
29223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29225 if (!SWIG_IsOK(res1)) {
29226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29227 }
29228 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29229 {
29230 arg2 = &temp2;
29231 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29232 }
29233 {
29234 PyThreadState* __tstate = wxPyBeginAllowThreads();
29235 (arg1)->SetPosition((wxPoint const &)*arg2);
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_Py_Void();
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *obj;
29248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29249 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29250 return SWIG_Py_Void();
29251 }
29252
29253 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29254 return SWIG_Python_InitShadowInstance(args);
29255 }
29256
29257 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29258 PyObject *resultobj = 0;
29259 wxIdleEvent *result = 0 ;
29260
29261 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 result = (wxIdleEvent *)new wxIdleEvent();
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29269 return resultobj;
29270 fail:
29271 return NULL;
29272 }
29273
29274
29275 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29276 PyObject *resultobj = 0;
29277 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29278 bool arg2 = (bool) true ;
29279 void *argp1 = 0 ;
29280 int res1 = 0 ;
29281 bool val2 ;
29282 int ecode2 = 0 ;
29283 PyObject * obj0 = 0 ;
29284 PyObject * obj1 = 0 ;
29285 char * kwnames[] = {
29286 (char *) "self",(char *) "needMore", NULL
29287 };
29288
29289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29293 }
29294 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29295 if (obj1) {
29296 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29297 if (!SWIG_IsOK(ecode2)) {
29298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29299 }
29300 arg2 = static_cast< bool >(val2);
29301 }
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 (arg1)->RequestMore(arg2);
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 resultobj = SWIG_Py_Void();
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29316 PyObject *resultobj = 0;
29317 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29318 bool result;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 PyObject *swig_obj[1] ;
29322
29323 if (!args) SWIG_fail;
29324 swig_obj[0] = args;
29325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29328 }
29329 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 {
29337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29338 }
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29346 PyObject *resultobj = 0;
29347 wxIdleMode arg1 ;
29348 int val1 ;
29349 int ecode1 = 0 ;
29350 PyObject * obj0 = 0 ;
29351 char * kwnames[] = {
29352 (char *) "mode", NULL
29353 };
29354
29355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29356 ecode1 = SWIG_AsVal_int(obj0, &val1);
29357 if (!SWIG_IsOK(ecode1)) {
29358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29359 }
29360 arg1 = static_cast< wxIdleMode >(val1);
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 wxIdleEvent::SetMode(arg1);
29364 wxPyEndAllowThreads(__tstate);
29365 if (PyErr_Occurred()) SWIG_fail;
29366 }
29367 resultobj = SWIG_Py_Void();
29368 return resultobj;
29369 fail:
29370 return NULL;
29371 }
29372
29373
29374 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29375 PyObject *resultobj = 0;
29376 wxIdleMode result;
29377
29378 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (wxIdleMode)wxIdleEvent::GetMode();
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 resultobj = SWIG_From_int(static_cast< int >(result));
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj = 0;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 bool result;
29396 void *argp1 = 0 ;
29397 int res1 = 0 ;
29398 PyObject * obj0 = 0 ;
29399 char * kwnames[] = {
29400 (char *) "win", NULL
29401 };
29402
29403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29405 if (!SWIG_IsOK(res1)) {
29406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29407 }
29408 arg1 = reinterpret_cast< wxWindow * >(argp1);
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 result = (bool)wxIdleEvent::CanSend(arg1);
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 {
29416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29417 }
29418 return resultobj;
29419 fail:
29420 return NULL;
29421 }
29422
29423
29424 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29425 PyObject *obj;
29426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29427 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29428 return SWIG_Py_Void();
29429 }
29430
29431 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29432 return SWIG_Python_InitShadowInstance(args);
29433 }
29434
29435 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29436 PyObject *resultobj = 0;
29437 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29438 int arg2 = (int) 0 ;
29439 wxClipboardTextEvent *result = 0 ;
29440 int val1 ;
29441 int ecode1 = 0 ;
29442 int val2 ;
29443 int ecode2 = 0 ;
29444 PyObject * obj0 = 0 ;
29445 PyObject * obj1 = 0 ;
29446 char * kwnames[] = {
29447 (char *) "type",(char *) "winid", NULL
29448 };
29449
29450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29451 if (obj0) {
29452 ecode1 = SWIG_AsVal_int(obj0, &val1);
29453 if (!SWIG_IsOK(ecode1)) {
29454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29455 }
29456 arg1 = static_cast< wxEventType >(val1);
29457 }
29458 if (obj1) {
29459 ecode2 = SWIG_AsVal_int(obj1, &val2);
29460 if (!SWIG_IsOK(ecode2)) {
29461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29462 }
29463 arg2 = static_cast< int >(val2);
29464 }
29465 {
29466 PyThreadState* __tstate = wxPyBeginAllowThreads();
29467 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29468 wxPyEndAllowThreads(__tstate);
29469 if (PyErr_Occurred()) SWIG_fail;
29470 }
29471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29479 PyObject *obj;
29480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29481 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29482 return SWIG_Py_Void();
29483 }
29484
29485 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29486 return SWIG_Python_InitShadowInstance(args);
29487 }
29488
29489 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29490 PyObject *resultobj = 0;
29491 int arg1 = (int) 0 ;
29492 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29493 wxPyEvent *result = 0 ;
29494 int val1 ;
29495 int ecode1 = 0 ;
29496 int val2 ;
29497 int ecode2 = 0 ;
29498 PyObject * obj0 = 0 ;
29499 PyObject * obj1 = 0 ;
29500 char * kwnames[] = {
29501 (char *) "winid",(char *) "eventType", NULL
29502 };
29503
29504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29505 if (obj0) {
29506 ecode1 = SWIG_AsVal_int(obj0, &val1);
29507 if (!SWIG_IsOK(ecode1)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29509 }
29510 arg1 = static_cast< int >(val1);
29511 }
29512 if (obj1) {
29513 ecode2 = SWIG_AsVal_int(obj1, &val2);
29514 if (!SWIG_IsOK(ecode2)) {
29515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29516 }
29517 arg2 = static_cast< wxEventType >(val2);
29518 }
29519 {
29520 PyThreadState* __tstate = wxPyBeginAllowThreads();
29521 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29522 wxPyEndAllowThreads(__tstate);
29523 if (PyErr_Occurred()) SWIG_fail;
29524 }
29525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29526 return resultobj;
29527 fail:
29528 return NULL;
29529 }
29530
29531
29532 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29533 PyObject *resultobj = 0;
29534 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29535 void *argp1 = 0 ;
29536 int res1 = 0 ;
29537 PyObject *swig_obj[1] ;
29538
29539 if (!args) SWIG_fail;
29540 swig_obj[0] = args;
29541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29542 if (!SWIG_IsOK(res1)) {
29543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29544 }
29545 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 delete arg1;
29549
29550 wxPyEndAllowThreads(__tstate);
29551 if (PyErr_Occurred()) SWIG_fail;
29552 }
29553 resultobj = SWIG_Py_Void();
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj = 0;
29562 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29563 PyObject *arg2 = (PyObject *) 0 ;
29564 void *argp1 = 0 ;
29565 int res1 = 0 ;
29566 PyObject * obj0 = 0 ;
29567 PyObject * obj1 = 0 ;
29568 char * kwnames[] = {
29569 (char *) "self",(char *) "self", NULL
29570 };
29571
29572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29574 if (!SWIG_IsOK(res1)) {
29575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29576 }
29577 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29578 arg2 = obj1;
29579 {
29580 PyThreadState* __tstate = wxPyBeginAllowThreads();
29581 (arg1)->SetSelf(arg2);
29582 wxPyEndAllowThreads(__tstate);
29583 if (PyErr_Occurred()) SWIG_fail;
29584 }
29585 resultobj = SWIG_Py_Void();
29586 return resultobj;
29587 fail:
29588 return NULL;
29589 }
29590
29591
29592 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29593 PyObject *resultobj = 0;
29594 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29595 PyObject *result = 0 ;
29596 void *argp1 = 0 ;
29597 int res1 = 0 ;
29598 PyObject *swig_obj[1] ;
29599
29600 if (!args) SWIG_fail;
29601 swig_obj[0] = args;
29602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29603 if (!SWIG_IsOK(res1)) {
29604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29605 }
29606 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (PyObject *)(arg1)->GetSelf();
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 resultobj = result;
29614 return resultobj;
29615 fail:
29616 return NULL;
29617 }
29618
29619
29620 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29621 PyObject *obj;
29622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29623 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29624 return SWIG_Py_Void();
29625 }
29626
29627 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 return SWIG_Python_InitShadowInstance(args);
29629 }
29630
29631 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj = 0;
29633 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29634 int arg2 = (int) 0 ;
29635 wxPyCommandEvent *result = 0 ;
29636 int val1 ;
29637 int ecode1 = 0 ;
29638 int val2 ;
29639 int ecode2 = 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "eventType",(char *) "id", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29647 if (obj0) {
29648 ecode1 = SWIG_AsVal_int(obj0, &val1);
29649 if (!SWIG_IsOK(ecode1)) {
29650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29651 }
29652 arg1 = static_cast< wxEventType >(val1);
29653 }
29654 if (obj1) {
29655 ecode2 = SWIG_AsVal_int(obj1, &val2);
29656 if (!SWIG_IsOK(ecode2)) {
29657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29658 }
29659 arg2 = static_cast< int >(val2);
29660 }
29661 {
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29664 wxPyEndAllowThreads(__tstate);
29665 if (PyErr_Occurred()) SWIG_fail;
29666 }
29667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29668 return resultobj;
29669 fail:
29670 return NULL;
29671 }
29672
29673
29674 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29675 PyObject *resultobj = 0;
29676 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29677 void *argp1 = 0 ;
29678 int res1 = 0 ;
29679 PyObject *swig_obj[1] ;
29680
29681 if (!args) SWIG_fail;
29682 swig_obj[0] = args;
29683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29684 if (!SWIG_IsOK(res1)) {
29685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29686 }
29687 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 delete arg1;
29691
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 resultobj = SWIG_Py_Void();
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj = 0;
29704 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29705 PyObject *arg2 = (PyObject *) 0 ;
29706 void *argp1 = 0 ;
29707 int res1 = 0 ;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 char * kwnames[] = {
29711 (char *) "self",(char *) "self", NULL
29712 };
29713
29714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29716 if (!SWIG_IsOK(res1)) {
29717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29718 }
29719 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29720 arg2 = obj1;
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 (arg1)->SetSelf(arg2);
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 resultobj = SWIG_Py_Void();
29728 return resultobj;
29729 fail:
29730 return NULL;
29731 }
29732
29733
29734 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29735 PyObject *resultobj = 0;
29736 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29737 PyObject *result = 0 ;
29738 void *argp1 = 0 ;
29739 int res1 = 0 ;
29740 PyObject *swig_obj[1] ;
29741
29742 if (!args) SWIG_fail;
29743 swig_obj[0] = args;
29744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29745 if (!SWIG_IsOK(res1)) {
29746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29747 }
29748 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 result = (PyObject *)(arg1)->GetSelf();
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 resultobj = result;
29756 return resultobj;
29757 fail:
29758 return NULL;
29759 }
29760
29761
29762 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29763 PyObject *obj;
29764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29765 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29766 return SWIG_Py_Void();
29767 }
29768
29769 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29770 return SWIG_Python_InitShadowInstance(args);
29771 }
29772
29773 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj = 0;
29775 wxWindow *arg1 = (wxWindow *) 0 ;
29776 wxDateTime *arg2 = 0 ;
29777 wxEventType arg3 ;
29778 wxDateEvent *result = 0 ;
29779 void *argp1 = 0 ;
29780 int res1 = 0 ;
29781 void *argp2 = 0 ;
29782 int res2 = 0 ;
29783 int val3 ;
29784 int ecode3 = 0 ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 PyObject * obj2 = 0 ;
29788 char * kwnames[] = {
29789 (char *) "win",(char *) "dt",(char *) "type", NULL
29790 };
29791
29792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29794 if (!SWIG_IsOK(res1)) {
29795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29796 }
29797 arg1 = reinterpret_cast< wxWindow * >(argp1);
29798 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29799 if (!SWIG_IsOK(res2)) {
29800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29801 }
29802 if (!argp2) {
29803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29804 }
29805 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29806 ecode3 = SWIG_AsVal_int(obj2, &val3);
29807 if (!SWIG_IsOK(ecode3)) {
29808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29809 }
29810 arg3 = static_cast< wxEventType >(val3);
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29818 return resultobj;
29819 fail:
29820 return NULL;
29821 }
29822
29823
29824 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29825 PyObject *resultobj = 0;
29826 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29827 wxDateTime *result = 0 ;
29828 void *argp1 = 0 ;
29829 int res1 = 0 ;
29830 PyObject *swig_obj[1] ;
29831
29832 if (!args) SWIG_fail;
29833 swig_obj[0] = args;
29834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29835 if (!SWIG_IsOK(res1)) {
29836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29837 }
29838 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 {
29842 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29843 result = (wxDateTime *) &_result_ref;
29844 }
29845 wxPyEndAllowThreads(__tstate);
29846 if (PyErr_Occurred()) SWIG_fail;
29847 }
29848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj = 0;
29857 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29858 wxDateTime *arg2 = 0 ;
29859 void *argp1 = 0 ;
29860 int res1 = 0 ;
29861 void *argp2 = 0 ;
29862 int res2 = 0 ;
29863 PyObject * obj0 = 0 ;
29864 PyObject * obj1 = 0 ;
29865 char * kwnames[] = {
29866 (char *) "self",(char *) "date", NULL
29867 };
29868
29869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29871 if (!SWIG_IsOK(res1)) {
29872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29873 }
29874 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29876 if (!SWIG_IsOK(res2)) {
29877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29878 }
29879 if (!argp2) {
29880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29881 }
29882 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 (arg1)->SetDate((wxDateTime const &)*arg2);
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 resultobj = SWIG_Py_Void();
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29897 PyObject *obj;
29898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29899 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29900 return SWIG_Py_Void();
29901 }
29902
29903 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29904 return SWIG_Python_InitShadowInstance(args);
29905 }
29906
29907 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 wxPyApp *result = 0 ;
29910
29911 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (wxPyApp *)new_wxPyApp();
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29926 PyObject *resultobj = 0;
29927 wxPyApp *arg1 = (wxPyApp *) 0 ;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 PyObject *swig_obj[1] ;
29931
29932 if (!args) SWIG_fail;
29933 swig_obj[0] = args;
29934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29937 }
29938 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 delete arg1;
29942
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 resultobj = SWIG_Py_Void();
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj = 0;
29955 wxPyApp *arg1 = (wxPyApp *) 0 ;
29956 PyObject *arg2 = (PyObject *) 0 ;
29957 PyObject *arg3 = (PyObject *) 0 ;
29958 bool arg4 = (bool) false ;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 bool val4 ;
29962 int ecode4 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 PyObject * obj1 = 0 ;
29965 PyObject * obj2 = 0 ;
29966 PyObject * obj3 = 0 ;
29967 char * kwnames[] = {
29968 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29969 };
29970
29971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29973 if (!SWIG_IsOK(res1)) {
29974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29975 }
29976 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29977 arg2 = obj1;
29978 arg3 = obj2;
29979 if (obj3) {
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 {
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 resultobj = SWIG_Py_Void();
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30000 PyObject *resultobj = 0;
30001 wxPyApp *arg1 = (wxPyApp *) 0 ;
30002 wxString result;
30003 void *argp1 = 0 ;
30004 int res1 = 0 ;
30005 PyObject *swig_obj[1] ;
30006
30007 if (!args) SWIG_fail;
30008 swig_obj[0] = args;
30009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30010 if (!SWIG_IsOK(res1)) {
30011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30012 }
30013 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 result = ((wxPyApp const *)arg1)->GetAppName();
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 #if wxUSE_UNICODE
30022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30023 #else
30024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30025 #endif
30026 }
30027 return resultobj;
30028 fail:
30029 return NULL;
30030 }
30031
30032
30033 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30034 PyObject *resultobj = 0;
30035 wxPyApp *arg1 = (wxPyApp *) 0 ;
30036 wxString *arg2 = 0 ;
30037 void *argp1 = 0 ;
30038 int res1 = 0 ;
30039 bool temp2 = false ;
30040 PyObject * obj0 = 0 ;
30041 PyObject * obj1 = 0 ;
30042 char * kwnames[] = {
30043 (char *) "self",(char *) "name", NULL
30044 };
30045
30046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30048 if (!SWIG_IsOK(res1)) {
30049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30050 }
30051 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30052 {
30053 arg2 = wxString_in_helper(obj1);
30054 if (arg2 == NULL) SWIG_fail;
30055 temp2 = true;
30056 }
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 (arg1)->SetAppName((wxString const &)*arg2);
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_Py_Void();
30064 {
30065 if (temp2)
30066 delete arg2;
30067 }
30068 return resultobj;
30069 fail:
30070 {
30071 if (temp2)
30072 delete arg2;
30073 }
30074 return NULL;
30075 }
30076
30077
30078 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30079 PyObject *resultobj = 0;
30080 wxPyApp *arg1 = (wxPyApp *) 0 ;
30081 wxString result;
30082 void *argp1 = 0 ;
30083 int res1 = 0 ;
30084 PyObject *swig_obj[1] ;
30085
30086 if (!args) SWIG_fail;
30087 swig_obj[0] = args;
30088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30089 if (!SWIG_IsOK(res1)) {
30090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30091 }
30092 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30093 {
30094 PyThreadState* __tstate = wxPyBeginAllowThreads();
30095 result = ((wxPyApp const *)arg1)->GetClassName();
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 {
30100 #if wxUSE_UNICODE
30101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30102 #else
30103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30104 #endif
30105 }
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj = 0;
30114 wxPyApp *arg1 = (wxPyApp *) 0 ;
30115 wxString *arg2 = 0 ;
30116 void *argp1 = 0 ;
30117 int res1 = 0 ;
30118 bool temp2 = false ;
30119 PyObject * obj0 = 0 ;
30120 PyObject * obj1 = 0 ;
30121 char * kwnames[] = {
30122 (char *) "self",(char *) "name", NULL
30123 };
30124
30125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30127 if (!SWIG_IsOK(res1)) {
30128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30129 }
30130 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30131 {
30132 arg2 = wxString_in_helper(obj1);
30133 if (arg2 == NULL) SWIG_fail;
30134 temp2 = true;
30135 }
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 (arg1)->SetClassName((wxString const &)*arg2);
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 resultobj = SWIG_Py_Void();
30143 {
30144 if (temp2)
30145 delete arg2;
30146 }
30147 return resultobj;
30148 fail:
30149 {
30150 if (temp2)
30151 delete arg2;
30152 }
30153 return NULL;
30154 }
30155
30156
30157 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30158 PyObject *resultobj = 0;
30159 wxPyApp *arg1 = (wxPyApp *) 0 ;
30160 wxString *result = 0 ;
30161 void *argp1 = 0 ;
30162 int res1 = 0 ;
30163 PyObject *swig_obj[1] ;
30164
30165 if (!args) SWIG_fail;
30166 swig_obj[0] = args;
30167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30168 if (!SWIG_IsOK(res1)) {
30169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30170 }
30171 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30172 {
30173 PyThreadState* __tstate = wxPyBeginAllowThreads();
30174 {
30175 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30176 result = (wxString *) &_result_ref;
30177 }
30178 wxPyEndAllowThreads(__tstate);
30179 if (PyErr_Occurred()) SWIG_fail;
30180 }
30181 {
30182 #if wxUSE_UNICODE
30183 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30184 #else
30185 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30186 #endif
30187 }
30188 return resultobj;
30189 fail:
30190 return NULL;
30191 }
30192
30193
30194 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30195 PyObject *resultobj = 0;
30196 wxPyApp *arg1 = (wxPyApp *) 0 ;
30197 wxString *arg2 = 0 ;
30198 void *argp1 = 0 ;
30199 int res1 = 0 ;
30200 bool temp2 = false ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 char * kwnames[] = {
30204 (char *) "self",(char *) "name", NULL
30205 };
30206
30207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30209 if (!SWIG_IsOK(res1)) {
30210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30211 }
30212 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30213 {
30214 arg2 = wxString_in_helper(obj1);
30215 if (arg2 == NULL) SWIG_fail;
30216 temp2 = true;
30217 }
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 (arg1)->SetVendorName((wxString const &)*arg2);
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 resultobj = SWIG_Py_Void();
30225 {
30226 if (temp2)
30227 delete arg2;
30228 }
30229 return resultobj;
30230 fail:
30231 {
30232 if (temp2)
30233 delete arg2;
30234 }
30235 return NULL;
30236 }
30237
30238
30239 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30240 PyObject *resultobj = 0;
30241 wxPyApp *arg1 = (wxPyApp *) 0 ;
30242 wxAppTraits *result = 0 ;
30243 void *argp1 = 0 ;
30244 int res1 = 0 ;
30245 PyObject *swig_obj[1] ;
30246
30247 if (!args) SWIG_fail;
30248 swig_obj[0] = args;
30249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30250 if (!SWIG_IsOK(res1)) {
30251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30252 }
30253 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 result = (wxAppTraits *)(arg1)->GetTraits();
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30261 return resultobj;
30262 fail:
30263 return NULL;
30264 }
30265
30266
30267 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30268 PyObject *resultobj = 0;
30269 wxPyApp *arg1 = (wxPyApp *) 0 ;
30270 void *argp1 = 0 ;
30271 int res1 = 0 ;
30272 PyObject *swig_obj[1] ;
30273
30274 if (!args) SWIG_fail;
30275 swig_obj[0] = args;
30276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30277 if (!SWIG_IsOK(res1)) {
30278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30279 }
30280 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 (arg1)->ProcessPendingEvents();
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_Py_Void();
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj = 0;
30296 wxPyApp *arg1 = (wxPyApp *) 0 ;
30297 bool arg2 = (bool) false ;
30298 bool result;
30299 void *argp1 = 0 ;
30300 int res1 = 0 ;
30301 bool val2 ;
30302 int ecode2 = 0 ;
30303 PyObject * obj0 = 0 ;
30304 PyObject * obj1 = 0 ;
30305 char * kwnames[] = {
30306 (char *) "self",(char *) "onlyIfNeeded", NULL
30307 };
30308
30309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30311 if (!SWIG_IsOK(res1)) {
30312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30313 }
30314 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30315 if (obj1) {
30316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30317 if (!SWIG_IsOK(ecode2)) {
30318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30319 }
30320 arg2 = static_cast< bool >(val2);
30321 }
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 result = (bool)(arg1)->Yield(arg2);
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 {
30329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30330 }
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 wxPyApp *arg1 = (wxPyApp *) 0 ;
30340 void *argp1 = 0 ;
30341 int res1 = 0 ;
30342 PyObject *swig_obj[1] ;
30343
30344 if (!args) SWIG_fail;
30345 swig_obj[0] = args;
30346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30347 if (!SWIG_IsOK(res1)) {
30348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30349 }
30350 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->WakeUpIdle();
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30365 PyObject *resultobj = 0;
30366 bool result;
30367
30368 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30369 {
30370 PyThreadState* __tstate = wxPyBeginAllowThreads();
30371 result = (bool)wxPyApp::IsMainLoopRunning();
30372 wxPyEndAllowThreads(__tstate);
30373 if (PyErr_Occurred()) SWIG_fail;
30374 }
30375 {
30376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30377 }
30378 return resultobj;
30379 fail:
30380 return NULL;
30381 }
30382
30383
30384 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30385 PyObject *resultobj = 0;
30386 wxPyApp *arg1 = (wxPyApp *) 0 ;
30387 int result;
30388 void *argp1 = 0 ;
30389 int res1 = 0 ;
30390 PyObject *swig_obj[1] ;
30391
30392 if (!args) SWIG_fail;
30393 swig_obj[0] = args;
30394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30395 if (!SWIG_IsOK(res1)) {
30396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30397 }
30398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = (int)(arg1)->MainLoop();
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_From_int(static_cast< int >(result));
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 PyObject *resultobj = 0;
30414 wxPyApp *arg1 = (wxPyApp *) 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 PyObject *swig_obj[1] ;
30418
30419 if (!args) SWIG_fail;
30420 swig_obj[0] = args;
30421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30424 }
30425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->Exit();
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30440 PyObject *resultobj = 0;
30441 wxPyApp *arg1 = (wxPyApp *) 0 ;
30442 wxLayoutDirection result;
30443 void *argp1 = 0 ;
30444 int res1 = 0 ;
30445 PyObject *swig_obj[1] ;
30446
30447 if (!args) SWIG_fail;
30448 swig_obj[0] = args;
30449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30450 if (!SWIG_IsOK(res1)) {
30451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30452 }
30453 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30454 {
30455 PyThreadState* __tstate = wxPyBeginAllowThreads();
30456 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30457 wxPyEndAllowThreads(__tstate);
30458 if (PyErr_Occurred()) SWIG_fail;
30459 }
30460 resultobj = SWIG_From_int(static_cast< int >(result));
30461 return resultobj;
30462 fail:
30463 return NULL;
30464 }
30465
30466
30467 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30468 PyObject *resultobj = 0;
30469 wxPyApp *arg1 = (wxPyApp *) 0 ;
30470 void *argp1 = 0 ;
30471 int res1 = 0 ;
30472 PyObject *swig_obj[1] ;
30473
30474 if (!args) SWIG_fail;
30475 swig_obj[0] = args;
30476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30477 if (!SWIG_IsOK(res1)) {
30478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30479 }
30480 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30481 {
30482 PyThreadState* __tstate = wxPyBeginAllowThreads();
30483 (arg1)->ExitMainLoop();
30484 wxPyEndAllowThreads(__tstate);
30485 if (PyErr_Occurred()) SWIG_fail;
30486 }
30487 resultobj = SWIG_Py_Void();
30488 return resultobj;
30489 fail:
30490 return NULL;
30491 }
30492
30493
30494 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30495 PyObject *resultobj = 0;
30496 wxPyApp *arg1 = (wxPyApp *) 0 ;
30497 bool result;
30498 void *argp1 = 0 ;
30499 int res1 = 0 ;
30500 PyObject *swig_obj[1] ;
30501
30502 if (!args) SWIG_fail;
30503 swig_obj[0] = args;
30504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30505 if (!SWIG_IsOK(res1)) {
30506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30507 }
30508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 result = (bool)(arg1)->Pending();
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 {
30516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30517 }
30518 return resultobj;
30519 fail:
30520 return NULL;
30521 }
30522
30523
30524 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30525 PyObject *resultobj = 0;
30526 wxPyApp *arg1 = (wxPyApp *) 0 ;
30527 bool result;
30528 void *argp1 = 0 ;
30529 int res1 = 0 ;
30530 PyObject *swig_obj[1] ;
30531
30532 if (!args) SWIG_fail;
30533 swig_obj[0] = args;
30534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30535 if (!SWIG_IsOK(res1)) {
30536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30537 }
30538 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 result = (bool)(arg1)->Dispatch();
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 {
30546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30547 }
30548 return resultobj;
30549 fail:
30550 return NULL;
30551 }
30552
30553
30554 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30555 PyObject *resultobj = 0;
30556 wxPyApp *arg1 = (wxPyApp *) 0 ;
30557 bool result;
30558 void *argp1 = 0 ;
30559 int res1 = 0 ;
30560 PyObject *swig_obj[1] ;
30561
30562 if (!args) SWIG_fail;
30563 swig_obj[0] = args;
30564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30567 }
30568 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 result = (bool)(arg1)->ProcessIdle();
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 {
30576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30577 }
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj = 0;
30586 wxPyApp *arg1 = (wxPyApp *) 0 ;
30587 wxWindow *arg2 = (wxWindow *) 0 ;
30588 wxIdleEvent *arg3 = 0 ;
30589 bool result;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 void *argp2 = 0 ;
30593 int res2 = 0 ;
30594 void *argp3 = 0 ;
30595 int res3 = 0 ;
30596 PyObject * obj0 = 0 ;
30597 PyObject * obj1 = 0 ;
30598 PyObject * obj2 = 0 ;
30599 char * kwnames[] = {
30600 (char *) "self",(char *) "win",(char *) "event", NULL
30601 };
30602
30603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30605 if (!SWIG_IsOK(res1)) {
30606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30607 }
30608 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30610 if (!SWIG_IsOK(res2)) {
30611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30612 }
30613 arg2 = reinterpret_cast< wxWindow * >(argp2);
30614 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30615 if (!SWIG_IsOK(res3)) {
30616 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30617 }
30618 if (!argp3) {
30619 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30620 }
30621 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 {
30629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30630 }
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30638 PyObject *resultobj = 0;
30639 wxPyApp *arg1 = (wxPyApp *) 0 ;
30640 bool result;
30641 void *argp1 = 0 ;
30642 int res1 = 0 ;
30643 PyObject *swig_obj[1] ;
30644
30645 if (!args) SWIG_fail;
30646 swig_obj[0] = args;
30647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30650 }
30651 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 result = (bool)((wxPyApp const *)arg1)->IsActive();
30655 wxPyEndAllowThreads(__tstate);
30656 if (PyErr_Occurred()) SWIG_fail;
30657 }
30658 {
30659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30660 }
30661 return resultobj;
30662 fail:
30663 return NULL;
30664 }
30665
30666
30667 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30668 PyObject *resultobj = 0;
30669 wxPyApp *arg1 = (wxPyApp *) 0 ;
30670 wxWindow *arg2 = (wxWindow *) 0 ;
30671 void *argp1 = 0 ;
30672 int res1 = 0 ;
30673 void *argp2 = 0 ;
30674 int res2 = 0 ;
30675 PyObject * obj0 = 0 ;
30676 PyObject * obj1 = 0 ;
30677 char * kwnames[] = {
30678 (char *) "self",(char *) "win", NULL
30679 };
30680
30681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30683 if (!SWIG_IsOK(res1)) {
30684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30685 }
30686 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res2)) {
30689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30690 }
30691 arg2 = reinterpret_cast< wxWindow * >(argp2);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 (arg1)->SetTopWindow(arg2);
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_Py_Void();
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxPyApp *arg1 = (wxPyApp *) 0 ;
30708 wxWindow *result = 0 ;
30709 void *argp1 = 0 ;
30710 int res1 = 0 ;
30711 PyObject *swig_obj[1] ;
30712
30713 if (!args) SWIG_fail;
30714 swig_obj[0] = args;
30715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30716 if (!SWIG_IsOK(res1)) {
30717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30718 }
30719 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 {
30727 resultobj = wxPyMake_wxObject(result, (bool)0);
30728 }
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30736 PyObject *resultobj = 0;
30737 wxPyApp *arg1 = (wxPyApp *) 0 ;
30738 bool arg2 ;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 bool val2 ;
30742 int ecode2 = 0 ;
30743 PyObject * obj0 = 0 ;
30744 PyObject * obj1 = 0 ;
30745 char * kwnames[] = {
30746 (char *) "self",(char *) "flag", NULL
30747 };
30748
30749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30751 if (!SWIG_IsOK(res1)) {
30752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30753 }
30754 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30756 if (!SWIG_IsOK(ecode2)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30758 }
30759 arg2 = static_cast< bool >(val2);
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 (arg1)->SetExitOnFrameDelete(arg2);
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 resultobj = SWIG_Py_Void();
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30774 PyObject *resultobj = 0;
30775 wxPyApp *arg1 = (wxPyApp *) 0 ;
30776 bool result;
30777 void *argp1 = 0 ;
30778 int res1 = 0 ;
30779 PyObject *swig_obj[1] ;
30780
30781 if (!args) SWIG_fail;
30782 swig_obj[0] = args;
30783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30784 if (!SWIG_IsOK(res1)) {
30785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30786 }
30787 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30791 wxPyEndAllowThreads(__tstate);
30792 if (PyErr_Occurred()) SWIG_fail;
30793 }
30794 {
30795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30796 }
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj = 0;
30805 wxPyApp *arg1 = (wxPyApp *) 0 ;
30806 bool arg2 ;
30807 bool arg3 = (bool) false ;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 bool val2 ;
30811 int ecode2 = 0 ;
30812 bool val3 ;
30813 int ecode3 = 0 ;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 PyObject * obj2 = 0 ;
30817 char * kwnames[] = {
30818 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30819 };
30820
30821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30825 }
30826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30828 if (!SWIG_IsOK(ecode2)) {
30829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30830 }
30831 arg2 = static_cast< bool >(val2);
30832 if (obj2) {
30833 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30834 if (!SWIG_IsOK(ecode3)) {
30835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30836 }
30837 arg3 = static_cast< bool >(val3);
30838 }
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 (arg1)->SetUseBestVisual(arg2,arg3);
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 resultobj = SWIG_Py_Void();
30846 return resultobj;
30847 fail:
30848 return NULL;
30849 }
30850
30851
30852 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30853 PyObject *resultobj = 0;
30854 wxPyApp *arg1 = (wxPyApp *) 0 ;
30855 bool result;
30856 void *argp1 = 0 ;
30857 int res1 = 0 ;
30858 PyObject *swig_obj[1] ;
30859
30860 if (!args) SWIG_fail;
30861 swig_obj[0] = args;
30862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30863 if (!SWIG_IsOK(res1)) {
30864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30865 }
30866 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 {
30874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30875 }
30876 return resultobj;
30877 fail:
30878 return NULL;
30879 }
30880
30881
30882 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30883 PyObject *resultobj = 0;
30884 wxPyApp *arg1 = (wxPyApp *) 0 ;
30885 int arg2 ;
30886 void *argp1 = 0 ;
30887 int res1 = 0 ;
30888 int val2 ;
30889 int ecode2 = 0 ;
30890 PyObject * obj0 = 0 ;
30891 PyObject * obj1 = 0 ;
30892 char * kwnames[] = {
30893 (char *) "self",(char *) "mode", NULL
30894 };
30895
30896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30898 if (!SWIG_IsOK(res1)) {
30899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30900 }
30901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30902 ecode2 = SWIG_AsVal_int(obj1, &val2);
30903 if (!SWIG_IsOK(ecode2)) {
30904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30905 }
30906 arg2 = static_cast< int >(val2);
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 (arg1)->SetPrintMode(arg2);
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_Py_Void();
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30921 PyObject *resultobj = 0;
30922 wxPyApp *arg1 = (wxPyApp *) 0 ;
30923 int result;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 PyObject *swig_obj[1] ;
30927
30928 if (!args) SWIG_fail;
30929 swig_obj[0] = args;
30930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30931 if (!SWIG_IsOK(res1)) {
30932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30933 }
30934 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30935 {
30936 PyThreadState* __tstate = wxPyBeginAllowThreads();
30937 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_From_int(static_cast< int >(result));
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = 0;
30950 wxPyApp *arg1 = (wxPyApp *) 0 ;
30951 int arg2 ;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 int val2 ;
30955 int ecode2 = 0 ;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 char * kwnames[] = {
30959 (char *) "self",(char *) "mode", NULL
30960 };
30961
30962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30964 if (!SWIG_IsOK(res1)) {
30965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30966 }
30967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30968 ecode2 = SWIG_AsVal_int(obj1, &val2);
30969 if (!SWIG_IsOK(ecode2)) {
30970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30971 }
30972 arg2 = static_cast< int >(val2);
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 (arg1)->SetAssertMode(arg2);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_Py_Void();
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 wxPyApp *arg1 = (wxPyApp *) 0 ;
30989 int result;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 PyObject *swig_obj[1] ;
30993
30994 if (!args) SWIG_fail;
30995 swig_obj[0] = args;
30996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30999 }
31000 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = (int)(arg1)->GetAssertMode();
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_From_int(static_cast< int >(result));
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 bool result;
31017
31018 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31019 {
31020 PyThreadState* __tstate = wxPyBeginAllowThreads();
31021 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 {
31026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31027 }
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31035 PyObject *resultobj = 0;
31036 long result;
31037
31038 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31039 {
31040 PyThreadState* __tstate = wxPyBeginAllowThreads();
31041 result = (long)wxPyApp::GetMacAboutMenuItemId();
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 resultobj = SWIG_From_long(static_cast< long >(result));
31046 return resultobj;
31047 fail:
31048 return NULL;
31049 }
31050
31051
31052 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31053 PyObject *resultobj = 0;
31054 long result;
31055
31056 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_From_long(static_cast< long >(result));
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 long result;
31073
31074 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 result = (long)wxPyApp::GetMacExitMenuItemId();
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_From_long(static_cast< long >(result));
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 wxString result;
31091
31092 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 result = wxPyApp::GetMacHelpMenuTitleName();
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 {
31100 #if wxUSE_UNICODE
31101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31102 #else
31103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31104 #endif
31105 }
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31113 PyObject *resultobj = 0;
31114 bool arg1 ;
31115 bool val1 ;
31116 int ecode1 = 0 ;
31117 PyObject * obj0 = 0 ;
31118 char * kwnames[] = {
31119 (char *) "val", NULL
31120 };
31121
31122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31123 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31124 if (!SWIG_IsOK(ecode1)) {
31125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31126 }
31127 arg1 = static_cast< bool >(val1);
31128 {
31129 PyThreadState* __tstate = wxPyBeginAllowThreads();
31130 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31131 wxPyEndAllowThreads(__tstate);
31132 if (PyErr_Occurred()) SWIG_fail;
31133 }
31134 resultobj = SWIG_Py_Void();
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj = 0;
31143 long arg1 ;
31144 long val1 ;
31145 int ecode1 = 0 ;
31146 PyObject * obj0 = 0 ;
31147 char * kwnames[] = {
31148 (char *) "val", NULL
31149 };
31150
31151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31152 ecode1 = SWIG_AsVal_long(obj0, &val1);
31153 if (!SWIG_IsOK(ecode1)) {
31154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31155 }
31156 arg1 = static_cast< long >(val1);
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 wxPyApp::SetMacAboutMenuItemId(arg1);
31160 wxPyEndAllowThreads(__tstate);
31161 if (PyErr_Occurred()) SWIG_fail;
31162 }
31163 resultobj = SWIG_Py_Void();
31164 return resultobj;
31165 fail:
31166 return NULL;
31167 }
31168
31169
31170 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31171 PyObject *resultobj = 0;
31172 long arg1 ;
31173 long val1 ;
31174 int ecode1 = 0 ;
31175 PyObject * obj0 = 0 ;
31176 char * kwnames[] = {
31177 (char *) "val", NULL
31178 };
31179
31180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31181 ecode1 = SWIG_AsVal_long(obj0, &val1);
31182 if (!SWIG_IsOK(ecode1)) {
31183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31184 }
31185 arg1 = static_cast< long >(val1);
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 resultobj = SWIG_Py_Void();
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31200 PyObject *resultobj = 0;
31201 long arg1 ;
31202 long val1 ;
31203 int ecode1 = 0 ;
31204 PyObject * obj0 = 0 ;
31205 char * kwnames[] = {
31206 (char *) "val", NULL
31207 };
31208
31209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31210 ecode1 = SWIG_AsVal_long(obj0, &val1);
31211 if (!SWIG_IsOK(ecode1)) {
31212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31213 }
31214 arg1 = static_cast< long >(val1);
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 wxPyApp::SetMacExitMenuItemId(arg1);
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_Py_Void();
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj = 0;
31230 wxString *arg1 = 0 ;
31231 bool temp1 = false ;
31232 PyObject * obj0 = 0 ;
31233 char * kwnames[] = {
31234 (char *) "val", NULL
31235 };
31236
31237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31238 {
31239 arg1 = wxString_in_helper(obj0);
31240 if (arg1 == NULL) SWIG_fail;
31241 temp1 = true;
31242 }
31243 {
31244 PyThreadState* __tstate = wxPyBeginAllowThreads();
31245 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 resultobj = SWIG_Py_Void();
31250 {
31251 if (temp1)
31252 delete arg1;
31253 }
31254 return resultobj;
31255 fail:
31256 {
31257 if (temp1)
31258 delete arg1;
31259 }
31260 return NULL;
31261 }
31262
31263
31264 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31265 PyObject *resultobj = 0;
31266 wxPyApp *arg1 = (wxPyApp *) 0 ;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31276 }
31277 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 (arg1)->_BootstrapApp();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 resultobj = SWIG_Py_Void();
31285 return resultobj;
31286 fail:
31287 return NULL;
31288 }
31289
31290
31291 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31292 PyObject *resultobj = 0;
31293 int result;
31294
31295 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31296 {
31297 PyThreadState* __tstate = wxPyBeginAllowThreads();
31298 result = (int)wxPyApp_GetComCtl32Version();
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 resultobj = SWIG_From_int(static_cast< int >(result));
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31310 PyObject *resultobj = 0;
31311 bool result;
31312
31313 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31314 {
31315 PyThreadState* __tstate = wxPyBeginAllowThreads();
31316 result = (bool)wxPyApp_IsDisplayAvailable();
31317 wxPyEndAllowThreads(__tstate);
31318 if (PyErr_Occurred()) SWIG_fail;
31319 }
31320 {
31321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31322 }
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31330 PyObject *obj;
31331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31332 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31333 return SWIG_Py_Void();
31334 }
31335
31336 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31337 return SWIG_Python_InitShadowInstance(args);
31338 }
31339
31340 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31341 PyObject *resultobj = 0;
31342
31343 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 wxExit();
31347 wxPyEndAllowThreads(__tstate);
31348 if (PyErr_Occurred()) SWIG_fail;
31349 }
31350 resultobj = SWIG_Py_Void();
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 bool result;
31360
31361 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = (bool)wxYield();
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 {
31369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31370 }
31371 return resultobj;
31372 fail:
31373 return NULL;
31374 }
31375
31376
31377 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31378 PyObject *resultobj = 0;
31379 bool result;
31380
31381 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (bool)wxYieldIfNeeded();
31385 wxPyEndAllowThreads(__tstate);
31386 if (PyErr_Occurred()) SWIG_fail;
31387 }
31388 {
31389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31390 }
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxWindow *arg1 = (wxWindow *) NULL ;
31400 bool arg2 = (bool) false ;
31401 bool result;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 bool val2 ;
31405 int ecode2 = 0 ;
31406 PyObject * obj0 = 0 ;
31407 PyObject * obj1 = 0 ;
31408 char * kwnames[] = {
31409 (char *) "win",(char *) "onlyIfNeeded", NULL
31410 };
31411
31412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31413 if (obj0) {
31414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31415 if (!SWIG_IsOK(res1)) {
31416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31417 }
31418 arg1 = reinterpret_cast< wxWindow * >(argp1);
31419 }
31420 if (obj1) {
31421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31422 if (!SWIG_IsOK(ecode2)) {
31423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31424 }
31425 arg2 = static_cast< bool >(val2);
31426 }
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 result = (bool)wxSafeYield(arg1,arg2);
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 {
31434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31435 }
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 PyObject *resultobj = 0;
31444
31445 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 wxWakeUpIdle();
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 resultobj = SWIG_Py_Void();
31453 return resultobj;
31454 fail:
31455 return NULL;
31456 }
31457
31458
31459 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31460 PyObject *resultobj = 0;
31461 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31462 wxEvent *arg2 = 0 ;
31463 void *argp1 = 0 ;
31464 int res1 = 0 ;
31465 void *argp2 = 0 ;
31466 int res2 = 0 ;
31467 PyObject * obj0 = 0 ;
31468 PyObject * obj1 = 0 ;
31469 char * kwnames[] = {
31470 (char *) "dest",(char *) "event", NULL
31471 };
31472
31473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31475 if (!SWIG_IsOK(res1)) {
31476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31477 }
31478 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31479 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31480 if (!SWIG_IsOK(res2)) {
31481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31482 }
31483 if (!argp2) {
31484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31485 }
31486 arg2 = reinterpret_cast< wxEvent * >(argp2);
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 wxPostEvent(arg1,*arg2);
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 resultobj = SWIG_Py_Void();
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31501 PyObject *resultobj = 0;
31502
31503 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 wxApp_CleanUp();
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 resultobj = SWIG_Py_Void();
31511 return resultobj;
31512 fail:
31513 return NULL;
31514 }
31515
31516
31517 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31518 PyObject *resultobj = 0;
31519 wxPyApp *result = 0 ;
31520
31521 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31522 {
31523 PyThreadState* __tstate = wxPyBeginAllowThreads();
31524 result = (wxPyApp *)wxPyGetApp();
31525 wxPyEndAllowThreads(__tstate);
31526 if (PyErr_Occurred()) SWIG_fail;
31527 }
31528 {
31529 resultobj = wxPyMake_wxObject(result, 0);
31530 }
31531 return resultobj;
31532 fail:
31533 return NULL;
31534 }
31535
31536
31537 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31538 PyObject *resultobj = 0;
31539 char *arg1 = (char *) 0 ;
31540 int res1 ;
31541 char *buf1 = 0 ;
31542 int alloc1 = 0 ;
31543 PyObject * obj0 = 0 ;
31544 char * kwnames[] = {
31545 (char *) "encoding", NULL
31546 };
31547
31548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31549 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31550 if (!SWIG_IsOK(res1)) {
31551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31552 }
31553 arg1 = buf1;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 wxSetDefaultPyEncoding((char const *)arg1);
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 resultobj = SWIG_Py_Void();
31561 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31562 return resultobj;
31563 fail:
31564 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31565 return NULL;
31566 }
31567
31568
31569 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31570 PyObject *resultobj = 0;
31571 char *result = 0 ;
31572
31573 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = (char *)wxGetDefaultPyEncoding();
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_FromCharPtr(result);
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589 wxEventLoop *result = 0 ;
31590
31591 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31592 {
31593 PyThreadState* __tstate = wxPyBeginAllowThreads();
31594 result = (wxEventLoop *)new wxEventLoop();
31595 wxPyEndAllowThreads(__tstate);
31596 if (PyErr_Occurred()) SWIG_fail;
31597 }
31598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31599 return resultobj;
31600 fail:
31601 return NULL;
31602 }
31603
31604
31605 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606 PyObject *resultobj = 0;
31607 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject *swig_obj[1] ;
31611
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31617 }
31618 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 delete arg1;
31622
31623 wxPyEndAllowThreads(__tstate);
31624 if (PyErr_Occurred()) SWIG_fail;
31625 }
31626 resultobj = SWIG_Py_Void();
31627 return resultobj;
31628 fail:
31629 return NULL;
31630 }
31631
31632
31633 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31634 PyObject *resultobj = 0;
31635 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31636 int result;
31637 void *argp1 = 0 ;
31638 int res1 = 0 ;
31639 PyObject *swig_obj[1] ;
31640
31641 if (!args) SWIG_fail;
31642 swig_obj[0] = args;
31643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31644 if (!SWIG_IsOK(res1)) {
31645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31646 }
31647 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 result = (int)(arg1)->Run();
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_From_int(static_cast< int >(result));
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = 0;
31663 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31664 int arg2 = (int) 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 int val2 ;
31668 int ecode2 = 0 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 char * kwnames[] = {
31672 (char *) "self",(char *) "rc", NULL
31673 };
31674
31675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31679 }
31680 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31681 if (obj1) {
31682 ecode2 = SWIG_AsVal_int(obj1, &val2);
31683 if (!SWIG_IsOK(ecode2)) {
31684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31685 }
31686 arg2 = static_cast< int >(val2);
31687 }
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 (arg1)->Exit(arg2);
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 resultobj = SWIG_Py_Void();
31695 return resultobj;
31696 fail:
31697 return NULL;
31698 }
31699
31700
31701 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702 PyObject *resultobj = 0;
31703 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31704 bool result;
31705 void *argp1 = 0 ;
31706 int res1 = 0 ;
31707 PyObject *swig_obj[1] ;
31708
31709 if (!args) SWIG_fail;
31710 swig_obj[0] = args;
31711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31712 if (!SWIG_IsOK(res1)) {
31713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31714 }
31715 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31716 {
31717 PyThreadState* __tstate = wxPyBeginAllowThreads();
31718 result = (bool)((wxEventLoop const *)arg1)->Pending();
31719 wxPyEndAllowThreads(__tstate);
31720 if (PyErr_Occurred()) SWIG_fail;
31721 }
31722 {
31723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31724 }
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31732 PyObject *resultobj = 0;
31733 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31734 bool result;
31735 void *argp1 = 0 ;
31736 int res1 = 0 ;
31737 PyObject *swig_obj[1] ;
31738
31739 if (!args) SWIG_fail;
31740 swig_obj[0] = args;
31741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31742 if (!SWIG_IsOK(res1)) {
31743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31744 }
31745 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31746 {
31747 PyThreadState* __tstate = wxPyBeginAllowThreads();
31748 result = (bool)(arg1)->Dispatch();
31749 wxPyEndAllowThreads(__tstate);
31750 if (PyErr_Occurred()) SWIG_fail;
31751 }
31752 {
31753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31754 }
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *resultobj = 0;
31763 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31764 bool result;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 PyObject *swig_obj[1] ;
31768
31769 if (!args) SWIG_fail;
31770 swig_obj[0] = args;
31771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31774 }
31775 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 {
31783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31784 }
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 PyObject *resultobj = 0;
31793 wxEventLoop *result = 0 ;
31794
31795 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31796 {
31797 PyThreadState* __tstate = wxPyBeginAllowThreads();
31798 result = (wxEventLoop *)wxEventLoop::GetActive();
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31803 return resultobj;
31804 fail:
31805 return NULL;
31806 }
31807
31808
31809 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31810 PyObject *resultobj = 0;
31811 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31812 void *argp1 = 0 ;
31813 int res1 = 0 ;
31814 PyObject * obj0 = 0 ;
31815 char * kwnames[] = {
31816 (char *) "loop", NULL
31817 };
31818
31819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31821 if (!SWIG_IsOK(res1)) {
31822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31823 }
31824 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31825 {
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 wxEventLoop::SetActive(arg1);
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 resultobj = SWIG_Py_Void();
31832 return resultobj;
31833 fail:
31834 return NULL;
31835 }
31836
31837
31838 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31839 PyObject *obj;
31840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31841 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31842 return SWIG_Py_Void();
31843 }
31844
31845 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31846 return SWIG_Python_InitShadowInstance(args);
31847 }
31848
31849 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = 0;
31851 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31852 wxEventLoopActivator *result = 0 ;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 PyObject * obj0 = 0 ;
31856 char * kwnames[] = {
31857 (char *) "evtLoop", NULL
31858 };
31859
31860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31862 if (!SWIG_IsOK(res1)) {
31863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31864 }
31865 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 PyObject *swig_obj[1] ;
31885
31886 if (!args) SWIG_fail;
31887 swig_obj[0] = args;
31888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31891 }
31892 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31893 {
31894 PyThreadState* __tstate = wxPyBeginAllowThreads();
31895 delete arg1;
31896
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_Py_Void();
31901 return resultobj;
31902 fail:
31903 return NULL;
31904 }
31905
31906
31907 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31908 PyObject *obj;
31909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31910 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31911 return SWIG_Py_Void();
31912 }
31913
31914 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31915 return SWIG_Python_InitShadowInstance(args);
31916 }
31917
31918 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj = 0;
31920 int arg1 = (int) 0 ;
31921 int arg2 = (int) 0 ;
31922 int arg3 = (int) 0 ;
31923 wxAcceleratorEntry *result = 0 ;
31924 int val1 ;
31925 int ecode1 = 0 ;
31926 int val2 ;
31927 int ecode2 = 0 ;
31928 int val3 ;
31929 int ecode3 = 0 ;
31930 PyObject * obj0 = 0 ;
31931 PyObject * obj1 = 0 ;
31932 PyObject * obj2 = 0 ;
31933 char * kwnames[] = {
31934 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31935 };
31936
31937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31938 if (obj0) {
31939 ecode1 = SWIG_AsVal_int(obj0, &val1);
31940 if (!SWIG_IsOK(ecode1)) {
31941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31942 }
31943 arg1 = static_cast< int >(val1);
31944 }
31945 if (obj1) {
31946 ecode2 = SWIG_AsVal_int(obj1, &val2);
31947 if (!SWIG_IsOK(ecode2)) {
31948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31949 }
31950 arg2 = static_cast< int >(val2);
31951 }
31952 if (obj2) {
31953 ecode3 = SWIG_AsVal_int(obj2, &val3);
31954 if (!SWIG_IsOK(ecode3)) {
31955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31956 }
31957 arg3 = static_cast< int >(val3);
31958 }
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31973 PyObject *resultobj = 0;
31974 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31975 void *argp1 = 0 ;
31976 int res1 = 0 ;
31977 PyObject *swig_obj[1] ;
31978
31979 if (!args) SWIG_fail;
31980 swig_obj[0] = args;
31981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31982 if (!SWIG_IsOK(res1)) {
31983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31984 }
31985 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31986 {
31987 PyThreadState* __tstate = wxPyBeginAllowThreads();
31988 delete arg1;
31989
31990 wxPyEndAllowThreads(__tstate);
31991 if (PyErr_Occurred()) SWIG_fail;
31992 }
31993 resultobj = SWIG_Py_Void();
31994 return resultobj;
31995 fail:
31996 return NULL;
31997 }
31998
31999
32000 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32001 PyObject *resultobj = 0;
32002 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32003 int arg2 ;
32004 int arg3 ;
32005 int arg4 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 int val2 ;
32009 int ecode2 = 0 ;
32010 int val3 ;
32011 int ecode3 = 0 ;
32012 int val4 ;
32013 int ecode4 = 0 ;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 PyObject * obj2 = 0 ;
32017 PyObject * obj3 = 0 ;
32018 char * kwnames[] = {
32019 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32020 };
32021
32022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32026 }
32027 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32028 ecode2 = SWIG_AsVal_int(obj1, &val2);
32029 if (!SWIG_IsOK(ecode2)) {
32030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32031 }
32032 arg2 = static_cast< int >(val2);
32033 ecode3 = SWIG_AsVal_int(obj2, &val3);
32034 if (!SWIG_IsOK(ecode3)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32036 }
32037 arg3 = static_cast< int >(val3);
32038 ecode4 = SWIG_AsVal_int(obj3, &val4);
32039 if (!SWIG_IsOK(ecode4)) {
32040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32041 }
32042 arg4 = static_cast< int >(val4);
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 (arg1)->Set(arg2,arg3,arg4);
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 resultobj = SWIG_Py_Void();
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32057 PyObject *resultobj = 0;
32058 wxString *arg1 = 0 ;
32059 wxAcceleratorEntry *result = 0 ;
32060 bool temp1 = false ;
32061 PyObject * obj0 = 0 ;
32062 char * kwnames[] = {
32063 (char *) "str", NULL
32064 };
32065
32066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32067 {
32068 arg1 = wxString_in_helper(obj0);
32069 if (arg1 == NULL) SWIG_fail;
32070 temp1 = true;
32071 }
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32079 {
32080 if (temp1)
32081 delete arg1;
32082 }
32083 return resultobj;
32084 fail:
32085 {
32086 if (temp1)
32087 delete arg1;
32088 }
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32094 PyObject *resultobj = 0;
32095 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32096 int result;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 PyObject *swig_obj[1] ;
32100
32101 if (!args) SWIG_fail;
32102 swig_obj[0] = args;
32103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32106 }
32107 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (int)(arg1)->GetFlags();
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_From_int(static_cast< int >(result));
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32122 PyObject *resultobj = 0;
32123 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32124 int result;
32125 void *argp1 = 0 ;
32126 int res1 = 0 ;
32127 PyObject *swig_obj[1] ;
32128
32129 if (!args) SWIG_fail;
32130 swig_obj[0] = args;
32131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32132 if (!SWIG_IsOK(res1)) {
32133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32134 }
32135 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32136 {
32137 PyThreadState* __tstate = wxPyBeginAllowThreads();
32138 result = (int)(arg1)->GetKeyCode();
32139 wxPyEndAllowThreads(__tstate);
32140 if (PyErr_Occurred()) SWIG_fail;
32141 }
32142 resultobj = SWIG_From_int(static_cast< int >(result));
32143 return resultobj;
32144 fail:
32145 return NULL;
32146 }
32147
32148
32149 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32150 PyObject *resultobj = 0;
32151 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32152 int result;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 PyObject *swig_obj[1] ;
32156
32157 if (!args) SWIG_fail;
32158 swig_obj[0] = args;
32159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32160 if (!SWIG_IsOK(res1)) {
32161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32162 }
32163 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (int)(arg1)->GetCommand();
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 resultobj = SWIG_From_int(static_cast< int >(result));
32171 return resultobj;
32172 fail:
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32178 PyObject *resultobj = 0;
32179 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32180 bool result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 PyObject *swig_obj[1] ;
32184
32185 if (!args) SWIG_fail;
32186 swig_obj[0] = args;
32187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32188 if (!SWIG_IsOK(res1)) {
32189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32190 }
32191 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 {
32199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32200 }
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32210 wxString result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 {
32229 #if wxUSE_UNICODE
32230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32231 #else
32232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32233 #endif
32234 }
32235 return resultobj;
32236 fail:
32237 return NULL;
32238 }
32239
32240
32241 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32242 PyObject *resultobj = 0;
32243 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32244 wxString *arg2 = 0 ;
32245 bool result;
32246 void *argp1 = 0 ;
32247 int res1 = 0 ;
32248 bool temp2 = false ;
32249 PyObject * obj0 = 0 ;
32250 PyObject * obj1 = 0 ;
32251 char * kwnames[] = {
32252 (char *) "self",(char *) "str", NULL
32253 };
32254
32255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32257 if (!SWIG_IsOK(res1)) {
32258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32259 }
32260 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32261 {
32262 arg2 = wxString_in_helper(obj1);
32263 if (arg2 == NULL) SWIG_fail;
32264 temp2 = true;
32265 }
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 {
32273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32274 }
32275 {
32276 if (temp2)
32277 delete arg2;
32278 }
32279 return resultobj;
32280 fail:
32281 {
32282 if (temp2)
32283 delete arg2;
32284 }
32285 return NULL;
32286 }
32287
32288
32289 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32290 PyObject *obj;
32291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32292 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32293 return SWIG_Py_Void();
32294 }
32295
32296 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32297 return SWIG_Python_InitShadowInstance(args);
32298 }
32299
32300 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj = 0;
32302 int arg1 ;
32303 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32304 wxAcceleratorTable *result = 0 ;
32305 PyObject * obj0 = 0 ;
32306 char * kwnames[] = {
32307 (char *) "n", NULL
32308 };
32309
32310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32311 {
32312 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32313 if (arg2) arg1 = PyList_Size(obj0);
32314 else arg1 = 0;
32315 }
32316 {
32317 PyThreadState* __tstate = wxPyBeginAllowThreads();
32318 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32332 void *argp1 = 0 ;
32333 int res1 = 0 ;
32334 PyObject *swig_obj[1] ;
32335
32336 if (!args) SWIG_fail;
32337 swig_obj[0] = args;
32338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32339 if (!SWIG_IsOK(res1)) {
32340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32341 }
32342 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 delete arg1;
32346
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 resultobj = SWIG_Py_Void();
32351 return resultobj;
32352 fail:
32353 return NULL;
32354 }
32355
32356
32357 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32358 PyObject *resultobj = 0;
32359 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32360 bool result;
32361 void *argp1 = 0 ;
32362 int res1 = 0 ;
32363 PyObject *swig_obj[1] ;
32364
32365 if (!args) SWIG_fail;
32366 swig_obj[0] = args;
32367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32368 if (!SWIG_IsOK(res1)) {
32369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32370 }
32371 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32372 {
32373 PyThreadState* __tstate = wxPyBeginAllowThreads();
32374 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 {
32379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32380 }
32381 return resultobj;
32382 fail:
32383 return NULL;
32384 }
32385
32386
32387 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32388 PyObject *obj;
32389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32390 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32391 return SWIG_Py_Void();
32392 }
32393
32394 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 return SWIG_Python_InitShadowInstance(args);
32396 }
32397
32398 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32399 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32400 return 1;
32401 }
32402
32403
32404 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32405 PyObject *pyobj = 0;
32406
32407 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32408 return pyobj;
32409 }
32410
32411
32412 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32413 PyObject *resultobj = 0;
32414 wxString *arg1 = 0 ;
32415 wxAcceleratorEntry *result = 0 ;
32416 bool temp1 = false ;
32417 PyObject * obj0 = 0 ;
32418 char * kwnames[] = {
32419 (char *) "label", NULL
32420 };
32421
32422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32423 {
32424 arg1 = wxString_in_helper(obj0);
32425 if (arg1 == NULL) SWIG_fail;
32426 temp1 = true;
32427 }
32428 {
32429 PyThreadState* __tstate = wxPyBeginAllowThreads();
32430 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32435 {
32436 if (temp1)
32437 delete arg1;
32438 }
32439 return resultobj;
32440 fail:
32441 {
32442 if (temp1)
32443 delete arg1;
32444 }
32445 return NULL;
32446 }
32447
32448
32449 SWIGINTERN int PanelNameStr_set(PyObject *) {
32450 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32451 return 1;
32452 }
32453
32454
32455 SWIGINTERN PyObject *PanelNameStr_get(void) {
32456 PyObject *pyobj = 0;
32457
32458 {
32459 #if wxUSE_UNICODE
32460 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32461 #else
32462 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32463 #endif
32464 }
32465 return pyobj;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32470 PyObject *resultobj = 0;
32471 wxVisualAttributes *result = 0 ;
32472
32473 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = (wxVisualAttributes *)new_wxVisualAttributes();
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32488 PyObject *resultobj = 0;
32489 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32490 void *argp1 = 0 ;
32491 int res1 = 0 ;
32492 PyObject *swig_obj[1] ;
32493
32494 if (!args) SWIG_fail;
32495 swig_obj[0] = args;
32496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32497 if (!SWIG_IsOK(res1)) {
32498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32499 }
32500 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 delete_wxVisualAttributes(arg1);
32504
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_Py_Void();
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32518 wxFont *arg2 = (wxFont *) 0 ;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 void *argp2 = 0 ;
32522 int res2 = 0 ;
32523 PyObject *swig_obj[2] ;
32524
32525 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32529 }
32530 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32531 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32532 if (!SWIG_IsOK(res2)) {
32533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32534 }
32535 arg2 = reinterpret_cast< wxFont * >(argp2);
32536 if (arg1) (arg1)->font = *arg2;
32537
32538 resultobj = SWIG_Py_Void();
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32546 PyObject *resultobj = 0;
32547 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32548 wxFont *result = 0 ;
32549 void *argp1 = 0 ;
32550 int res1 = 0 ;
32551 PyObject *swig_obj[1] ;
32552
32553 if (!args) SWIG_fail;
32554 swig_obj[0] = args;
32555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32558 }
32559 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32560 result = (wxFont *)& ((arg1)->font);
32561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32562 return resultobj;
32563 fail:
32564 return NULL;
32565 }
32566
32567
32568 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32569 PyObject *resultobj = 0;
32570 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32571 wxColour *arg2 = (wxColour *) 0 ;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 void *argp2 = 0 ;
32575 int res2 = 0 ;
32576 PyObject *swig_obj[2] ;
32577
32578 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32580 if (!SWIG_IsOK(res1)) {
32581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32582 }
32583 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32584 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32585 if (!SWIG_IsOK(res2)) {
32586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32587 }
32588 arg2 = reinterpret_cast< wxColour * >(argp2);
32589 if (arg1) (arg1)->colFg = *arg2;
32590
32591 resultobj = SWIG_Py_Void();
32592 return resultobj;
32593 fail:
32594 return NULL;
32595 }
32596
32597
32598 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32599 PyObject *resultobj = 0;
32600 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32601 wxColour *result = 0 ;
32602 void *argp1 = 0 ;
32603 int res1 = 0 ;
32604 PyObject *swig_obj[1] ;
32605
32606 if (!args) SWIG_fail;
32607 swig_obj[0] = args;
32608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32609 if (!SWIG_IsOK(res1)) {
32610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32611 }
32612 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32613 result = (wxColour *)& ((arg1)->colFg);
32614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32622 PyObject *resultobj = 0;
32623 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32624 wxColour *arg2 = (wxColour *) 0 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 void *argp2 = 0 ;
32628 int res2 = 0 ;
32629 PyObject *swig_obj[2] ;
32630
32631 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32635 }
32636 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32638 if (!SWIG_IsOK(res2)) {
32639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32640 }
32641 arg2 = reinterpret_cast< wxColour * >(argp2);
32642 if (arg1) (arg1)->colBg = *arg2;
32643
32644 resultobj = SWIG_Py_Void();
32645 return resultobj;
32646 fail:
32647 return NULL;
32648 }
32649
32650
32651 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32652 PyObject *resultobj = 0;
32653 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32654 wxColour *result = 0 ;
32655 void *argp1 = 0 ;
32656 int res1 = 0 ;
32657 PyObject *swig_obj[1] ;
32658
32659 if (!args) SWIG_fail;
32660 swig_obj[0] = args;
32661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32662 if (!SWIG_IsOK(res1)) {
32663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32664 }
32665 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32666 result = (wxColour *)& ((arg1)->colBg);
32667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32675 PyObject *obj;
32676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32677 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32678 return SWIG_Py_Void();
32679 }
32680
32681 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32682 return SWIG_Python_InitShadowInstance(args);
32683 }
32684
32685 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32686 PyObject *resultobj = 0;
32687 wxWindow *arg1 = (wxWindow *) 0 ;
32688 int arg2 = (int) (int)-1 ;
32689 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32690 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32691 wxSize const &arg4_defvalue = wxDefaultSize ;
32692 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32693 long arg5 = (long) 0 ;
32694 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32695 wxString *arg6 = (wxString *) &arg6_defvalue ;
32696 wxWindow *result = 0 ;
32697 void *argp1 = 0 ;
32698 int res1 = 0 ;
32699 int val2 ;
32700 int ecode2 = 0 ;
32701 wxPoint temp3 ;
32702 wxSize temp4 ;
32703 long val5 ;
32704 int ecode5 = 0 ;
32705 bool temp6 = false ;
32706 PyObject * obj0 = 0 ;
32707 PyObject * obj1 = 0 ;
32708 PyObject * obj2 = 0 ;
32709 PyObject * obj3 = 0 ;
32710 PyObject * obj4 = 0 ;
32711 PyObject * obj5 = 0 ;
32712 char * kwnames[] = {
32713 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32714 };
32715
32716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32718 if (!SWIG_IsOK(res1)) {
32719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32720 }
32721 arg1 = reinterpret_cast< wxWindow * >(argp1);
32722 if (obj1) {
32723 ecode2 = SWIG_AsVal_int(obj1, &val2);
32724 if (!SWIG_IsOK(ecode2)) {
32725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32726 }
32727 arg2 = static_cast< int >(val2);
32728 }
32729 if (obj2) {
32730 {
32731 arg3 = &temp3;
32732 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32733 }
32734 }
32735 if (obj3) {
32736 {
32737 arg4 = &temp4;
32738 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32739 }
32740 }
32741 if (obj4) {
32742 ecode5 = SWIG_AsVal_long(obj4, &val5);
32743 if (!SWIG_IsOK(ecode5)) {
32744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32745 }
32746 arg5 = static_cast< long >(val5);
32747 }
32748 if (obj5) {
32749 {
32750 arg6 = wxString_in_helper(obj5);
32751 if (arg6 == NULL) SWIG_fail;
32752 temp6 = true;
32753 }
32754 }
32755 {
32756 if (!wxPyCheckForApp()) SWIG_fail;
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32763 {
32764 if (temp6)
32765 delete arg6;
32766 }
32767 return resultobj;
32768 fail:
32769 {
32770 if (temp6)
32771 delete arg6;
32772 }
32773 return NULL;
32774 }
32775
32776
32777 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32778 PyObject *resultobj = 0;
32779 wxWindow *result = 0 ;
32780
32781 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32782 {
32783 if (!wxPyCheckForApp()) SWIG_fail;
32784 PyThreadState* __tstate = wxPyBeginAllowThreads();
32785 result = (wxWindow *)new wxWindow();
32786 wxPyEndAllowThreads(__tstate);
32787 if (PyErr_Occurred()) SWIG_fail;
32788 }
32789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32797 PyObject *resultobj = 0;
32798 wxWindow *arg1 = (wxWindow *) 0 ;
32799 wxWindow *arg2 = (wxWindow *) 0 ;
32800 int arg3 = (int) (int)-1 ;
32801 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32802 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32803 wxSize const &arg5_defvalue = wxDefaultSize ;
32804 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32805 long arg6 = (long) 0 ;
32806 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32807 wxString *arg7 = (wxString *) &arg7_defvalue ;
32808 bool result;
32809 void *argp1 = 0 ;
32810 int res1 = 0 ;
32811 void *argp2 = 0 ;
32812 int res2 = 0 ;
32813 int val3 ;
32814 int ecode3 = 0 ;
32815 wxPoint temp4 ;
32816 wxSize temp5 ;
32817 long val6 ;
32818 int ecode6 = 0 ;
32819 bool temp7 = false ;
32820 PyObject * obj0 = 0 ;
32821 PyObject * obj1 = 0 ;
32822 PyObject * obj2 = 0 ;
32823 PyObject * obj3 = 0 ;
32824 PyObject * obj4 = 0 ;
32825 PyObject * obj5 = 0 ;
32826 PyObject * obj6 = 0 ;
32827 char * kwnames[] = {
32828 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32829 };
32830
32831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res2)) {
32839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32840 }
32841 arg2 = reinterpret_cast< wxWindow * >(argp2);
32842 if (obj2) {
32843 ecode3 = SWIG_AsVal_int(obj2, &val3);
32844 if (!SWIG_IsOK(ecode3)) {
32845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32846 }
32847 arg3 = static_cast< int >(val3);
32848 }
32849 if (obj3) {
32850 {
32851 arg4 = &temp4;
32852 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32853 }
32854 }
32855 if (obj4) {
32856 {
32857 arg5 = &temp5;
32858 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32859 }
32860 }
32861 if (obj5) {
32862 ecode6 = SWIG_AsVal_long(obj5, &val6);
32863 if (!SWIG_IsOK(ecode6)) {
32864 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32865 }
32866 arg6 = static_cast< long >(val6);
32867 }
32868 if (obj6) {
32869 {
32870 arg7 = wxString_in_helper(obj6);
32871 if (arg7 == NULL) SWIG_fail;
32872 temp7 = true;
32873 }
32874 }
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 {
32882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32883 }
32884 {
32885 if (temp7)
32886 delete arg7;
32887 }
32888 return resultobj;
32889 fail:
32890 {
32891 if (temp7)
32892 delete arg7;
32893 }
32894 return NULL;
32895 }
32896
32897
32898 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32899 PyObject *resultobj = 0;
32900 wxWindow *arg1 = (wxWindow *) 0 ;
32901 bool arg2 = (bool) false ;
32902 bool result;
32903 void *argp1 = 0 ;
32904 int res1 = 0 ;
32905 bool val2 ;
32906 int ecode2 = 0 ;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 char * kwnames[] = {
32910 (char *) "self",(char *) "force", NULL
32911 };
32912
32913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32917 }
32918 arg1 = reinterpret_cast< wxWindow * >(argp1);
32919 if (obj1) {
32920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32921 if (!SWIG_IsOK(ecode2)) {
32922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32923 }
32924 arg2 = static_cast< bool >(val2);
32925 }
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (bool)(arg1)->Close(arg2);
32929 wxPyEndAllowThreads(__tstate);
32930 if (PyErr_Occurred()) SWIG_fail;
32931 }
32932 {
32933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32934 }
32935 return resultobj;
32936 fail:
32937 return NULL;
32938 }
32939
32940
32941 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32942 PyObject *resultobj = 0;
32943 wxWindow *arg1 = (wxWindow *) 0 ;
32944 bool result;
32945 void *argp1 = 0 ;
32946 int res1 = 0 ;
32947 PyObject *swig_obj[1] ;
32948
32949 if (!args) SWIG_fail;
32950 swig_obj[0] = args;
32951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32952 if (!SWIG_IsOK(res1)) {
32953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32954 }
32955 arg1 = reinterpret_cast< wxWindow * >(argp1);
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 result = (bool)(arg1)->Destroy();
32959 wxPyEndAllowThreads(__tstate);
32960 if (PyErr_Occurred()) SWIG_fail;
32961 }
32962 {
32963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32964 }
32965 return resultobj;
32966 fail:
32967 return NULL;
32968 }
32969
32970
32971 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32972 PyObject *resultobj = 0;
32973 wxWindow *arg1 = (wxWindow *) 0 ;
32974 bool result;
32975 void *argp1 = 0 ;
32976 int res1 = 0 ;
32977 PyObject *swig_obj[1] ;
32978
32979 if (!args) SWIG_fail;
32980 swig_obj[0] = args;
32981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32982 if (!SWIG_IsOK(res1)) {
32983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32984 }
32985 arg1 = reinterpret_cast< wxWindow * >(argp1);
32986 {
32987 PyThreadState* __tstate = wxPyBeginAllowThreads();
32988 result = (bool)(arg1)->DestroyChildren();
32989 wxPyEndAllowThreads(__tstate);
32990 if (PyErr_Occurred()) SWIG_fail;
32991 }
32992 {
32993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32994 }
32995 return resultobj;
32996 fail:
32997 return NULL;
32998 }
32999
33000
33001 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33002 PyObject *resultobj = 0;
33003 wxWindow *arg1 = (wxWindow *) 0 ;
33004 bool result;
33005 void *argp1 = 0 ;
33006 int res1 = 0 ;
33007 PyObject *swig_obj[1] ;
33008
33009 if (!args) SWIG_fail;
33010 swig_obj[0] = args;
33011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33014 }
33015 arg1 = reinterpret_cast< wxWindow * >(argp1);
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 {
33023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33024 }
33025 return resultobj;
33026 fail:
33027 return NULL;
33028 }
33029
33030
33031 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33032 PyObject *resultobj = 0;
33033 wxWindow *arg1 = (wxWindow *) 0 ;
33034 wxString *arg2 = 0 ;
33035 void *argp1 = 0 ;
33036 int res1 = 0 ;
33037 bool temp2 = false ;
33038 PyObject * obj0 = 0 ;
33039 PyObject * obj1 = 0 ;
33040 char * kwnames[] = {
33041 (char *) "self",(char *) "label", NULL
33042 };
33043
33044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res1)) {
33047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33048 }
33049 arg1 = reinterpret_cast< wxWindow * >(argp1);
33050 {
33051 arg2 = wxString_in_helper(obj1);
33052 if (arg2 == NULL) SWIG_fail;
33053 temp2 = true;
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 (arg1)->SetLabel((wxString const &)*arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_Py_Void();
33062 {
33063 if (temp2)
33064 delete arg2;
33065 }
33066 return resultobj;
33067 fail:
33068 {
33069 if (temp2)
33070 delete arg2;
33071 }
33072 return NULL;
33073 }
33074
33075
33076 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33077 PyObject *resultobj = 0;
33078 wxWindow *arg1 = (wxWindow *) 0 ;
33079 wxString result;
33080 void *argp1 = 0 ;
33081 int res1 = 0 ;
33082 PyObject *swig_obj[1] ;
33083
33084 if (!args) SWIG_fail;
33085 swig_obj[0] = args;
33086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33087 if (!SWIG_IsOK(res1)) {
33088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33089 }
33090 arg1 = reinterpret_cast< wxWindow * >(argp1);
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = ((wxWindow const *)arg1)->GetLabel();
33094 wxPyEndAllowThreads(__tstate);
33095 if (PyErr_Occurred()) SWIG_fail;
33096 }
33097 {
33098 #if wxUSE_UNICODE
33099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33100 #else
33101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33102 #endif
33103 }
33104 return resultobj;
33105 fail:
33106 return NULL;
33107 }
33108
33109
33110 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33111 PyObject *resultobj = 0;
33112 wxWindow *arg1 = (wxWindow *) 0 ;
33113 wxString *arg2 = 0 ;
33114 void *argp1 = 0 ;
33115 int res1 = 0 ;
33116 bool temp2 = false ;
33117 PyObject * obj0 = 0 ;
33118 PyObject * obj1 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "self",(char *) "name", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33125 if (!SWIG_IsOK(res1)) {
33126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33127 }
33128 arg1 = reinterpret_cast< wxWindow * >(argp1);
33129 {
33130 arg2 = wxString_in_helper(obj1);
33131 if (arg2 == NULL) SWIG_fail;
33132 temp2 = true;
33133 }
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 (arg1)->SetName((wxString const &)*arg2);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_Py_Void();
33141 {
33142 if (temp2)
33143 delete arg2;
33144 }
33145 return resultobj;
33146 fail:
33147 {
33148 if (temp2)
33149 delete arg2;
33150 }
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33156 PyObject *resultobj = 0;
33157 wxWindow *arg1 = (wxWindow *) 0 ;
33158 wxString result;
33159 void *argp1 = 0 ;
33160 int res1 = 0 ;
33161 PyObject *swig_obj[1] ;
33162
33163 if (!args) SWIG_fail;
33164 swig_obj[0] = args;
33165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33168 }
33169 arg1 = reinterpret_cast< wxWindow * >(argp1);
33170 {
33171 PyThreadState* __tstate = wxPyBeginAllowThreads();
33172 result = ((wxWindow const *)arg1)->GetName();
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 {
33177 #if wxUSE_UNICODE
33178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33179 #else
33180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33181 #endif
33182 }
33183 return resultobj;
33184 fail:
33185 return NULL;
33186 }
33187
33188
33189 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33190 PyObject *resultobj = 0;
33191 wxWindow *arg1 = (wxWindow *) 0 ;
33192 wxWindowVariant arg2 ;
33193 void *argp1 = 0 ;
33194 int res1 = 0 ;
33195 int val2 ;
33196 int ecode2 = 0 ;
33197 PyObject * obj0 = 0 ;
33198 PyObject * obj1 = 0 ;
33199 char * kwnames[] = {
33200 (char *) "self",(char *) "variant", NULL
33201 };
33202
33203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33205 if (!SWIG_IsOK(res1)) {
33206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33207 }
33208 arg1 = reinterpret_cast< wxWindow * >(argp1);
33209 ecode2 = SWIG_AsVal_int(obj1, &val2);
33210 if (!SWIG_IsOK(ecode2)) {
33211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33212 }
33213 arg2 = static_cast< wxWindowVariant >(val2);
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 (arg1)->SetWindowVariant(arg2);
33217 wxPyEndAllowThreads(__tstate);
33218 if (PyErr_Occurred()) SWIG_fail;
33219 }
33220 resultobj = SWIG_Py_Void();
33221 return resultobj;
33222 fail:
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 wxWindowVariant result;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 PyObject *swig_obj[1] ;
33234
33235 if (!args) SWIG_fail;
33236 swig_obj[0] = args;
33237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33238 if (!SWIG_IsOK(res1)) {
33239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33240 }
33241 arg1 = reinterpret_cast< wxWindow * >(argp1);
33242 {
33243 PyThreadState* __tstate = wxPyBeginAllowThreads();
33244 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33245 wxPyEndAllowThreads(__tstate);
33246 if (PyErr_Occurred()) SWIG_fail;
33247 }
33248 resultobj = SWIG_From_int(static_cast< int >(result));
33249 return resultobj;
33250 fail:
33251 return NULL;
33252 }
33253
33254
33255 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33256 PyObject *resultobj = 0;
33257 wxWindow *arg1 = (wxWindow *) 0 ;
33258 int arg2 ;
33259 void *argp1 = 0 ;
33260 int res1 = 0 ;
33261 int val2 ;
33262 int ecode2 = 0 ;
33263 PyObject * obj0 = 0 ;
33264 PyObject * obj1 = 0 ;
33265 char * kwnames[] = {
33266 (char *) "self",(char *) "winid", NULL
33267 };
33268
33269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33271 if (!SWIG_IsOK(res1)) {
33272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33273 }
33274 arg1 = reinterpret_cast< wxWindow * >(argp1);
33275 ecode2 = SWIG_AsVal_int(obj1, &val2);
33276 if (!SWIG_IsOK(ecode2)) {
33277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33278 }
33279 arg2 = static_cast< int >(val2);
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 (arg1)->SetId(arg2);
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 resultobj = SWIG_Py_Void();
33287 return resultobj;
33288 fail:
33289 return NULL;
33290 }
33291
33292
33293 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33294 PyObject *resultobj = 0;
33295 wxWindow *arg1 = (wxWindow *) 0 ;
33296 int result;
33297 void *argp1 = 0 ;
33298 int res1 = 0 ;
33299 PyObject *swig_obj[1] ;
33300
33301 if (!args) SWIG_fail;
33302 swig_obj[0] = args;
33303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33304 if (!SWIG_IsOK(res1)) {
33305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33306 }
33307 arg1 = reinterpret_cast< wxWindow * >(argp1);
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 result = (int)((wxWindow const *)arg1)->GetId();
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 resultobj = SWIG_From_int(static_cast< int >(result));
33315 return resultobj;
33316 fail:
33317 return NULL;
33318 }
33319
33320
33321 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33322 PyObject *resultobj = 0;
33323 int result;
33324
33325 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 result = (int)wxWindow::NewControlId();
33329 wxPyEndAllowThreads(__tstate);
33330 if (PyErr_Occurred()) SWIG_fail;
33331 }
33332 resultobj = SWIG_From_int(static_cast< int >(result));
33333 return resultobj;
33334 fail:
33335 return NULL;
33336 }
33337
33338
33339 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33340 PyObject *resultobj = 0;
33341 int arg1 ;
33342 int result;
33343 int val1 ;
33344 int ecode1 = 0 ;
33345 PyObject * obj0 = 0 ;
33346 char * kwnames[] = {
33347 (char *) "winid", NULL
33348 };
33349
33350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33351 ecode1 = SWIG_AsVal_int(obj0, &val1);
33352 if (!SWIG_IsOK(ecode1)) {
33353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33354 }
33355 arg1 = static_cast< int >(val1);
33356 {
33357 PyThreadState* __tstate = wxPyBeginAllowThreads();
33358 result = (int)wxWindow::NextControlId(arg1);
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 resultobj = SWIG_From_int(static_cast< int >(result));
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj = 0;
33371 int arg1 ;
33372 int result;
33373 int val1 ;
33374 int ecode1 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 char * kwnames[] = {
33377 (char *) "winid", NULL
33378 };
33379
33380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33381 ecode1 = SWIG_AsVal_int(obj0, &val1);
33382 if (!SWIG_IsOK(ecode1)) {
33383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33384 }
33385 arg1 = static_cast< int >(val1);
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (int)wxWindow::PrevControlId(arg1);
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_From_int(static_cast< int >(result));
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33400 PyObject *resultobj = 0;
33401 wxWindow *arg1 = (wxWindow *) 0 ;
33402 wxLayoutDirection result;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 PyObject *swig_obj[1] ;
33406
33407 if (!args) SWIG_fail;
33408 swig_obj[0] = args;
33409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33410 if (!SWIG_IsOK(res1)) {
33411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33412 }
33413 arg1 = reinterpret_cast< wxWindow * >(argp1);
33414 {
33415 PyThreadState* __tstate = wxPyBeginAllowThreads();
33416 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33417 wxPyEndAllowThreads(__tstate);
33418 if (PyErr_Occurred()) SWIG_fail;
33419 }
33420 resultobj = SWIG_From_int(static_cast< int >(result));
33421 return resultobj;
33422 fail:
33423 return NULL;
33424 }
33425
33426
33427 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33428 PyObject *resultobj = 0;
33429 wxWindow *arg1 = (wxWindow *) 0 ;
33430 wxLayoutDirection arg2 ;
33431 void *argp1 = 0 ;
33432 int res1 = 0 ;
33433 int val2 ;
33434 int ecode2 = 0 ;
33435 PyObject * obj0 = 0 ;
33436 PyObject * obj1 = 0 ;
33437 char * kwnames[] = {
33438 (char *) "self",(char *) "dir", NULL
33439 };
33440
33441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33443 if (!SWIG_IsOK(res1)) {
33444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33445 }
33446 arg1 = reinterpret_cast< wxWindow * >(argp1);
33447 ecode2 = SWIG_AsVal_int(obj1, &val2);
33448 if (!SWIG_IsOK(ecode2)) {
33449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33450 }
33451 arg2 = static_cast< wxLayoutDirection >(val2);
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 (arg1)->SetLayoutDirection(arg2);
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_Py_Void();
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33466 PyObject *resultobj = 0;
33467 wxWindow *arg1 = (wxWindow *) 0 ;
33468 int arg2 ;
33469 int arg3 ;
33470 int arg4 ;
33471 int result;
33472 void *argp1 = 0 ;
33473 int res1 = 0 ;
33474 int val2 ;
33475 int ecode2 = 0 ;
33476 int val3 ;
33477 int ecode3 = 0 ;
33478 int val4 ;
33479 int ecode4 = 0 ;
33480 PyObject * obj0 = 0 ;
33481 PyObject * obj1 = 0 ;
33482 PyObject * obj2 = 0 ;
33483 PyObject * obj3 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33492 }
33493 arg1 = reinterpret_cast< wxWindow * >(argp1);
33494 ecode2 = SWIG_AsVal_int(obj1, &val2);
33495 if (!SWIG_IsOK(ecode2)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33497 }
33498 arg2 = static_cast< int >(val2);
33499 ecode3 = SWIG_AsVal_int(obj2, &val3);
33500 if (!SWIG_IsOK(ecode3)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33502 }
33503 arg3 = static_cast< int >(val3);
33504 ecode4 = SWIG_AsVal_int(obj3, &val4);
33505 if (!SWIG_IsOK(ecode4)) {
33506 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33507 }
33508 arg4 = static_cast< int >(val4);
33509 {
33510 PyThreadState* __tstate = wxPyBeginAllowThreads();
33511 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33512 wxPyEndAllowThreads(__tstate);
33513 if (PyErr_Occurred()) SWIG_fail;
33514 }
33515 resultobj = SWIG_From_int(static_cast< int >(result));
33516 return resultobj;
33517 fail:
33518 return NULL;
33519 }
33520
33521
33522 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33523 PyObject *resultobj = 0;
33524 wxWindow *arg1 = (wxWindow *) 0 ;
33525 wxSize *arg2 = 0 ;
33526 void *argp1 = 0 ;
33527 int res1 = 0 ;
33528 wxSize temp2 ;
33529 PyObject * obj0 = 0 ;
33530 PyObject * obj1 = 0 ;
33531 char * kwnames[] = {
33532 (char *) "self",(char *) "size", NULL
33533 };
33534
33535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33537 if (!SWIG_IsOK(res1)) {
33538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33539 }
33540 arg1 = reinterpret_cast< wxWindow * >(argp1);
33541 {
33542 arg2 = &temp2;
33543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 (arg1)->SetSize((wxSize const &)*arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 resultobj = SWIG_Py_Void();
33552 return resultobj;
33553 fail:
33554 return NULL;
33555 }
33556
33557
33558 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 int arg2 ;
33562 int arg3 ;
33563 int arg4 ;
33564 int arg5 ;
33565 int arg6 = (int) wxSIZE_AUTO ;
33566 void *argp1 = 0 ;
33567 int res1 = 0 ;
33568 int val2 ;
33569 int ecode2 = 0 ;
33570 int val3 ;
33571 int ecode3 = 0 ;
33572 int val4 ;
33573 int ecode4 = 0 ;
33574 int val5 ;
33575 int ecode5 = 0 ;
33576 int val6 ;
33577 int ecode6 = 0 ;
33578 PyObject * obj0 = 0 ;
33579 PyObject * obj1 = 0 ;
33580 PyObject * obj2 = 0 ;
33581 PyObject * obj3 = 0 ;
33582 PyObject * obj4 = 0 ;
33583 PyObject * obj5 = 0 ;
33584 char * kwnames[] = {
33585 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33586 };
33587
33588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33590 if (!SWIG_IsOK(res1)) {
33591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33592 }
33593 arg1 = reinterpret_cast< wxWindow * >(argp1);
33594 ecode2 = SWIG_AsVal_int(obj1, &val2);
33595 if (!SWIG_IsOK(ecode2)) {
33596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33597 }
33598 arg2 = static_cast< int >(val2);
33599 ecode3 = SWIG_AsVal_int(obj2, &val3);
33600 if (!SWIG_IsOK(ecode3)) {
33601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33602 }
33603 arg3 = static_cast< int >(val3);
33604 ecode4 = SWIG_AsVal_int(obj3, &val4);
33605 if (!SWIG_IsOK(ecode4)) {
33606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33607 }
33608 arg4 = static_cast< int >(val4);
33609 ecode5 = SWIG_AsVal_int(obj4, &val5);
33610 if (!SWIG_IsOK(ecode5)) {
33611 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33612 }
33613 arg5 = static_cast< int >(val5);
33614 if (obj5) {
33615 ecode6 = SWIG_AsVal_int(obj5, &val6);
33616 if (!SWIG_IsOK(ecode6)) {
33617 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33618 }
33619 arg6 = static_cast< int >(val6);
33620 }
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33624 wxPyEndAllowThreads(__tstate);
33625 if (PyErr_Occurred()) SWIG_fail;
33626 }
33627 resultobj = SWIG_Py_Void();
33628 return resultobj;
33629 fail:
33630 return NULL;
33631 }
33632
33633
33634 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33635 PyObject *resultobj = 0;
33636 wxWindow *arg1 = (wxWindow *) 0 ;
33637 wxRect *arg2 = 0 ;
33638 int arg3 = (int) wxSIZE_AUTO ;
33639 void *argp1 = 0 ;
33640 int res1 = 0 ;
33641 wxRect temp2 ;
33642 int val3 ;
33643 int ecode3 = 0 ;
33644 PyObject * obj0 = 0 ;
33645 PyObject * obj1 = 0 ;
33646 PyObject * obj2 = 0 ;
33647 char * kwnames[] = {
33648 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33649 };
33650
33651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33653 if (!SWIG_IsOK(res1)) {
33654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33655 }
33656 arg1 = reinterpret_cast< wxWindow * >(argp1);
33657 {
33658 arg2 = &temp2;
33659 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33660 }
33661 if (obj2) {
33662 ecode3 = SWIG_AsVal_int(obj2, &val3);
33663 if (!SWIG_IsOK(ecode3)) {
33664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33665 }
33666 arg3 = static_cast< int >(val3);
33667 }
33668 {
33669 PyThreadState* __tstate = wxPyBeginAllowThreads();
33670 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33671 wxPyEndAllowThreads(__tstate);
33672 if (PyErr_Occurred()) SWIG_fail;
33673 }
33674 resultobj = SWIG_Py_Void();
33675 return resultobj;
33676 fail:
33677 return NULL;
33678 }
33679
33680
33681 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33682 PyObject *resultobj = 0;
33683 wxWindow *arg1 = (wxWindow *) 0 ;
33684 int arg2 ;
33685 int arg3 ;
33686 void *argp1 = 0 ;
33687 int res1 = 0 ;
33688 int val2 ;
33689 int ecode2 = 0 ;
33690 int val3 ;
33691 int ecode3 = 0 ;
33692 PyObject * obj0 = 0 ;
33693 PyObject * obj1 = 0 ;
33694 PyObject * obj2 = 0 ;
33695 char * kwnames[] = {
33696 (char *) "self",(char *) "width",(char *) "height", NULL
33697 };
33698
33699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 ecode2 = SWIG_AsVal_int(obj1, &val2);
33706 if (!SWIG_IsOK(ecode2)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33708 }
33709 arg2 = static_cast< int >(val2);
33710 ecode3 = SWIG_AsVal_int(obj2, &val3);
33711 if (!SWIG_IsOK(ecode3)) {
33712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33713 }
33714 arg3 = static_cast< int >(val3);
33715 {
33716 PyThreadState* __tstate = wxPyBeginAllowThreads();
33717 (arg1)->SetSize(arg2,arg3);
33718 wxPyEndAllowThreads(__tstate);
33719 if (PyErr_Occurred()) SWIG_fail;
33720 }
33721 resultobj = SWIG_Py_Void();
33722 return resultobj;
33723 fail:
33724 return NULL;
33725 }
33726
33727
33728 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33729 PyObject *resultobj = 0;
33730 wxWindow *arg1 = (wxWindow *) 0 ;
33731 wxPoint *arg2 = 0 ;
33732 int arg3 = (int) wxSIZE_USE_EXISTING ;
33733 void *argp1 = 0 ;
33734 int res1 = 0 ;
33735 wxPoint temp2 ;
33736 int val3 ;
33737 int ecode3 = 0 ;
33738 PyObject * obj0 = 0 ;
33739 PyObject * obj1 = 0 ;
33740 PyObject * obj2 = 0 ;
33741 char * kwnames[] = {
33742 (char *) "self",(char *) "pt",(char *) "flags", NULL
33743 };
33744
33745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33747 if (!SWIG_IsOK(res1)) {
33748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33749 }
33750 arg1 = reinterpret_cast< wxWindow * >(argp1);
33751 {
33752 arg2 = &temp2;
33753 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33754 }
33755 if (obj2) {
33756 ecode3 = SWIG_AsVal_int(obj2, &val3);
33757 if (!SWIG_IsOK(ecode3)) {
33758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33759 }
33760 arg3 = static_cast< int >(val3);
33761 }
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 (arg1)->Move((wxPoint const &)*arg2,arg3);
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 resultobj = SWIG_Py_Void();
33769 return resultobj;
33770 fail:
33771 return NULL;
33772 }
33773
33774
33775 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj = 0;
33777 wxWindow *arg1 = (wxWindow *) 0 ;
33778 int arg2 ;
33779 int arg3 ;
33780 int arg4 = (int) wxSIZE_USE_EXISTING ;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 int val2 ;
33784 int ecode2 = 0 ;
33785 int val3 ;
33786 int ecode3 = 0 ;
33787 int val4 ;
33788 int ecode4 = 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 PyObject * obj2 = 0 ;
33792 PyObject * obj3 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33801 }
33802 arg1 = reinterpret_cast< wxWindow * >(argp1);
33803 ecode2 = SWIG_AsVal_int(obj1, &val2);
33804 if (!SWIG_IsOK(ecode2)) {
33805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33806 }
33807 arg2 = static_cast< int >(val2);
33808 ecode3 = SWIG_AsVal_int(obj2, &val3);
33809 if (!SWIG_IsOK(ecode3)) {
33810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33811 }
33812 arg3 = static_cast< int >(val3);
33813 if (obj3) {
33814 ecode4 = SWIG_AsVal_int(obj3, &val4);
33815 if (!SWIG_IsOK(ecode4)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33817 }
33818 arg4 = static_cast< int >(val4);
33819 }
33820 {
33821 PyThreadState* __tstate = wxPyBeginAllowThreads();
33822 (arg1)->Move(arg2,arg3,arg4);
33823 wxPyEndAllowThreads(__tstate);
33824 if (PyErr_Occurred()) SWIG_fail;
33825 }
33826 resultobj = SWIG_Py_Void();
33827 return resultobj;
33828 fail:
33829 return NULL;
33830 }
33831
33832
33833 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33834 PyObject *resultobj = 0;
33835 wxWindow *arg1 = (wxWindow *) 0 ;
33836 wxSize const &arg2_defvalue = wxDefaultSize ;
33837 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33838 void *argp1 = 0 ;
33839 int res1 = 0 ;
33840 wxSize temp2 ;
33841 PyObject * obj0 = 0 ;
33842 PyObject * obj1 = 0 ;
33843 char * kwnames[] = {
33844 (char *) "self",(char *) "size", NULL
33845 };
33846
33847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33849 if (!SWIG_IsOK(res1)) {
33850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33851 }
33852 arg1 = reinterpret_cast< wxWindow * >(argp1);
33853 if (obj1) {
33854 {
33855 arg2 = &temp2;
33856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33857 }
33858 }
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 (arg1)->SetInitialSize((wxSize const &)*arg2);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_Py_Void();
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 void *argp1 = 0 ;
33876 int res1 = 0 ;
33877 PyObject *swig_obj[1] ;
33878
33879 if (!args) SWIG_fail;
33880 swig_obj[0] = args;
33881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33882 if (!SWIG_IsOK(res1)) {
33883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33884 }
33885 arg1 = reinterpret_cast< wxWindow * >(argp1);
33886 {
33887 PyThreadState* __tstate = wxPyBeginAllowThreads();
33888 (arg1)->Raise();
33889 wxPyEndAllowThreads(__tstate);
33890 if (PyErr_Occurred()) SWIG_fail;
33891 }
33892 resultobj = SWIG_Py_Void();
33893 return resultobj;
33894 fail:
33895 return NULL;
33896 }
33897
33898
33899 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33900 PyObject *resultobj = 0;
33901 wxWindow *arg1 = (wxWindow *) 0 ;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 PyObject *swig_obj[1] ;
33905
33906 if (!args) SWIG_fail;
33907 swig_obj[0] = args;
33908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33909 if (!SWIG_IsOK(res1)) {
33910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33911 }
33912 arg1 = reinterpret_cast< wxWindow * >(argp1);
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 (arg1)->Lower();
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 resultobj = SWIG_Py_Void();
33920 return resultobj;
33921 fail:
33922 return NULL;
33923 }
33924
33925
33926 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33927 PyObject *resultobj = 0;
33928 wxWindow *arg1 = (wxWindow *) 0 ;
33929 wxSize *arg2 = 0 ;
33930 void *argp1 = 0 ;
33931 int res1 = 0 ;
33932 wxSize temp2 ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 char * kwnames[] = {
33936 (char *) "self",(char *) "size", NULL
33937 };
33938
33939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33941 if (!SWIG_IsOK(res1)) {
33942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33943 }
33944 arg1 = reinterpret_cast< wxWindow * >(argp1);
33945 {
33946 arg2 = &temp2;
33947 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33948 }
33949 {
33950 PyThreadState* __tstate = wxPyBeginAllowThreads();
33951 (arg1)->SetClientSize((wxSize const &)*arg2);
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 resultobj = SWIG_Py_Void();
33956 return resultobj;
33957 fail:
33958 return NULL;
33959 }
33960
33961
33962 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33963 PyObject *resultobj = 0;
33964 wxWindow *arg1 = (wxWindow *) 0 ;
33965 int arg2 ;
33966 int arg3 ;
33967 void *argp1 = 0 ;
33968 int res1 = 0 ;
33969 int val2 ;
33970 int ecode2 = 0 ;
33971 int val3 ;
33972 int ecode3 = 0 ;
33973 PyObject * obj0 = 0 ;
33974 PyObject * obj1 = 0 ;
33975 PyObject * obj2 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "width",(char *) "height", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 ecode2 = SWIG_AsVal_int(obj1, &val2);
33987 if (!SWIG_IsOK(ecode2)) {
33988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33989 }
33990 arg2 = static_cast< int >(val2);
33991 ecode3 = SWIG_AsVal_int(obj2, &val3);
33992 if (!SWIG_IsOK(ecode3)) {
33993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33994 }
33995 arg3 = static_cast< int >(val3);
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 (arg1)->SetClientSize(arg2,arg3);
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_Py_Void();
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxWindow *arg1 = (wxWindow *) 0 ;
34012 wxRect *arg2 = 0 ;
34013 void *argp1 = 0 ;
34014 int res1 = 0 ;
34015 wxRect temp2 ;
34016 PyObject * obj0 = 0 ;
34017 PyObject * obj1 = 0 ;
34018 char * kwnames[] = {
34019 (char *) "self",(char *) "rect", NULL
34020 };
34021
34022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34024 if (!SWIG_IsOK(res1)) {
34025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34026 }
34027 arg1 = reinterpret_cast< wxWindow * >(argp1);
34028 {
34029 arg2 = &temp2;
34030 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34031 }
34032 {
34033 PyThreadState* __tstate = wxPyBeginAllowThreads();
34034 (arg1)->SetClientSize((wxRect const &)*arg2);
34035 wxPyEndAllowThreads(__tstate);
34036 if (PyErr_Occurred()) SWIG_fail;
34037 }
34038 resultobj = SWIG_Py_Void();
34039 return resultobj;
34040 fail:
34041 return NULL;
34042 }
34043
34044
34045 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34046 PyObject *resultobj = 0;
34047 wxWindow *arg1 = (wxWindow *) 0 ;
34048 wxPoint result;
34049 void *argp1 = 0 ;
34050 int res1 = 0 ;
34051 PyObject *swig_obj[1] ;
34052
34053 if (!args) SWIG_fail;
34054 swig_obj[0] = args;
34055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34056 if (!SWIG_IsOK(res1)) {
34057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34058 }
34059 arg1 = reinterpret_cast< wxWindow * >(argp1);
34060 {
34061 PyThreadState* __tstate = wxPyBeginAllowThreads();
34062 result = ((wxWindow const *)arg1)->GetPosition();
34063 wxPyEndAllowThreads(__tstate);
34064 if (PyErr_Occurred()) SWIG_fail;
34065 }
34066 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34067 return resultobj;
34068 fail:
34069 return NULL;
34070 }
34071
34072
34073 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34074 PyObject *resultobj = 0;
34075 wxWindow *arg1 = (wxWindow *) 0 ;
34076 int *arg2 = (int *) 0 ;
34077 int *arg3 = (int *) 0 ;
34078 void *argp1 = 0 ;
34079 int res1 = 0 ;
34080 int temp2 ;
34081 int res2 = SWIG_TMPOBJ ;
34082 int temp3 ;
34083 int res3 = SWIG_TMPOBJ ;
34084 PyObject *swig_obj[1] ;
34085
34086 arg2 = &temp2;
34087 arg3 = &temp3;
34088 if (!args) SWIG_fail;
34089 swig_obj[0] = args;
34090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34091 if (!SWIG_IsOK(res1)) {
34092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34093 }
34094 arg1 = reinterpret_cast< wxWindow * >(argp1);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 resultobj = SWIG_Py_Void();
34102 if (SWIG_IsTmpObj(res2)) {
34103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34104 } else {
34105 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34107 }
34108 if (SWIG_IsTmpObj(res3)) {
34109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34110 } else {
34111 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34113 }
34114 return resultobj;
34115 fail:
34116 return NULL;
34117 }
34118
34119
34120 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34121 PyObject *resultobj = 0;
34122 wxWindow *arg1 = (wxWindow *) 0 ;
34123 wxPoint result;
34124 void *argp1 = 0 ;
34125 int res1 = 0 ;
34126 PyObject *swig_obj[1] ;
34127
34128 if (!args) SWIG_fail;
34129 swig_obj[0] = args;
34130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34131 if (!SWIG_IsOK(res1)) {
34132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34133 }
34134 arg1 = reinterpret_cast< wxWindow * >(argp1);
34135 {
34136 PyThreadState* __tstate = wxPyBeginAllowThreads();
34137 result = ((wxWindow const *)arg1)->GetScreenPosition();
34138 wxPyEndAllowThreads(__tstate);
34139 if (PyErr_Occurred()) SWIG_fail;
34140 }
34141 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34142 return resultobj;
34143 fail:
34144 return NULL;
34145 }
34146
34147
34148 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34149 PyObject *resultobj = 0;
34150 wxWindow *arg1 = (wxWindow *) 0 ;
34151 int *arg2 = (int *) 0 ;
34152 int *arg3 = (int *) 0 ;
34153 void *argp1 = 0 ;
34154 int res1 = 0 ;
34155 int temp2 ;
34156 int res2 = SWIG_TMPOBJ ;
34157 int temp3 ;
34158 int res3 = SWIG_TMPOBJ ;
34159 PyObject *swig_obj[1] ;
34160
34161 arg2 = &temp2;
34162 arg3 = &temp3;
34163 if (!args) SWIG_fail;
34164 swig_obj[0] = args;
34165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34166 if (!SWIG_IsOK(res1)) {
34167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34168 }
34169 arg1 = reinterpret_cast< wxWindow * >(argp1);
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_Py_Void();
34177 if (SWIG_IsTmpObj(res2)) {
34178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34179 } else {
34180 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34182 }
34183 if (SWIG_IsTmpObj(res3)) {
34184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34185 } else {
34186 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34188 }
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 wxRect result;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 PyObject *swig_obj[1] ;
34202
34203 if (!args) SWIG_fail;
34204 swig_obj[0] = args;
34205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34206 if (!SWIG_IsOK(res1)) {
34207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34208 }
34209 arg1 = reinterpret_cast< wxWindow * >(argp1);
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = ((wxWindow const *)arg1)->GetScreenRect();
34213 wxPyEndAllowThreads(__tstate);
34214 if (PyErr_Occurred()) SWIG_fail;
34215 }
34216 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34217 return resultobj;
34218 fail:
34219 return NULL;
34220 }
34221
34222
34223 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34224 PyObject *resultobj = 0;
34225 wxWindow *arg1 = (wxWindow *) 0 ;
34226 wxSize result;
34227 void *argp1 = 0 ;
34228 int res1 = 0 ;
34229 PyObject *swig_obj[1] ;
34230
34231 if (!args) SWIG_fail;
34232 swig_obj[0] = args;
34233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34234 if (!SWIG_IsOK(res1)) {
34235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34236 }
34237 arg1 = reinterpret_cast< wxWindow * >(argp1);
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 result = ((wxWindow const *)arg1)->GetSize();
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *resultobj = 0;
34253 wxWindow *arg1 = (wxWindow *) 0 ;
34254 int *arg2 = (int *) 0 ;
34255 int *arg3 = (int *) 0 ;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 int temp2 ;
34259 int res2 = SWIG_TMPOBJ ;
34260 int temp3 ;
34261 int res3 = SWIG_TMPOBJ ;
34262 PyObject *swig_obj[1] ;
34263
34264 arg2 = &temp2;
34265 arg3 = &temp3;
34266 if (!args) SWIG_fail;
34267 swig_obj[0] = args;
34268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34271 }
34272 arg1 = reinterpret_cast< wxWindow * >(argp1);
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34276 wxPyEndAllowThreads(__tstate);
34277 if (PyErr_Occurred()) SWIG_fail;
34278 }
34279 resultobj = SWIG_Py_Void();
34280 if (SWIG_IsTmpObj(res2)) {
34281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34282 } else {
34283 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34285 }
34286 if (SWIG_IsTmpObj(res3)) {
34287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34288 } else {
34289 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34291 }
34292 return resultobj;
34293 fail:
34294 return NULL;
34295 }
34296
34297
34298 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34299 PyObject *resultobj = 0;
34300 wxWindow *arg1 = (wxWindow *) 0 ;
34301 wxRect result;
34302 void *argp1 = 0 ;
34303 int res1 = 0 ;
34304 PyObject *swig_obj[1] ;
34305
34306 if (!args) SWIG_fail;
34307 swig_obj[0] = args;
34308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34311 }
34312 arg1 = reinterpret_cast< wxWindow * >(argp1);
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 result = ((wxWindow const *)arg1)->GetRect();
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34327 PyObject *resultobj = 0;
34328 wxWindow *arg1 = (wxWindow *) 0 ;
34329 wxSize result;
34330 void *argp1 = 0 ;
34331 int res1 = 0 ;
34332 PyObject *swig_obj[1] ;
34333
34334 if (!args) SWIG_fail;
34335 swig_obj[0] = args;
34336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34339 }
34340 arg1 = reinterpret_cast< wxWindow * >(argp1);
34341 {
34342 PyThreadState* __tstate = wxPyBeginAllowThreads();
34343 result = ((wxWindow const *)arg1)->GetClientSize();
34344 wxPyEndAllowThreads(__tstate);
34345 if (PyErr_Occurred()) SWIG_fail;
34346 }
34347 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34348 return resultobj;
34349 fail:
34350 return NULL;
34351 }
34352
34353
34354 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34355 PyObject *resultobj = 0;
34356 wxWindow *arg1 = (wxWindow *) 0 ;
34357 int *arg2 = (int *) 0 ;
34358 int *arg3 = (int *) 0 ;
34359 void *argp1 = 0 ;
34360 int res1 = 0 ;
34361 int temp2 ;
34362 int res2 = SWIG_TMPOBJ ;
34363 int temp3 ;
34364 int res3 = SWIG_TMPOBJ ;
34365 PyObject *swig_obj[1] ;
34366
34367 arg2 = &temp2;
34368 arg3 = &temp3;
34369 if (!args) SWIG_fail;
34370 swig_obj[0] = args;
34371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34372 if (!SWIG_IsOK(res1)) {
34373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34374 }
34375 arg1 = reinterpret_cast< wxWindow * >(argp1);
34376 {
34377 PyThreadState* __tstate = wxPyBeginAllowThreads();
34378 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 resultobj = SWIG_Py_Void();
34383 if (SWIG_IsTmpObj(res2)) {
34384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34385 } else {
34386 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34388 }
34389 if (SWIG_IsTmpObj(res3)) {
34390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34391 } else {
34392 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34394 }
34395 return resultobj;
34396 fail:
34397 return NULL;
34398 }
34399
34400
34401 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34402 PyObject *resultobj = 0;
34403 wxWindow *arg1 = (wxWindow *) 0 ;
34404 wxPoint result;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 PyObject *swig_obj[1] ;
34408
34409 if (!args) SWIG_fail;
34410 swig_obj[0] = args;
34411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34412 if (!SWIG_IsOK(res1)) {
34413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34414 }
34415 arg1 = reinterpret_cast< wxWindow * >(argp1);
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34419 wxPyEndAllowThreads(__tstate);
34420 if (PyErr_Occurred()) SWIG_fail;
34421 }
34422 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34423 return resultobj;
34424 fail:
34425 return NULL;
34426 }
34427
34428
34429 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34430 PyObject *resultobj = 0;
34431 wxWindow *arg1 = (wxWindow *) 0 ;
34432 wxRect result;
34433 void *argp1 = 0 ;
34434 int res1 = 0 ;
34435 PyObject *swig_obj[1] ;
34436
34437 if (!args) SWIG_fail;
34438 swig_obj[0] = args;
34439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34440 if (!SWIG_IsOK(res1)) {
34441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34442 }
34443 arg1 = reinterpret_cast< wxWindow * >(argp1);
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = ((wxWindow const *)arg1)->GetClientRect();
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxWindow *arg1 = (wxWindow *) 0 ;
34460 wxSize result;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 PyObject *swig_obj[1] ;
34464
34465 if (!args) SWIG_fail;
34466 swig_obj[0] = args;
34467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34470 }
34471 arg1 = reinterpret_cast< wxWindow * >(argp1);
34472 {
34473 PyThreadState* __tstate = wxPyBeginAllowThreads();
34474 result = ((wxWindow const *)arg1)->GetBestSize();
34475 wxPyEndAllowThreads(__tstate);
34476 if (PyErr_Occurred()) SWIG_fail;
34477 }
34478 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34479 return resultobj;
34480 fail:
34481 return NULL;
34482 }
34483
34484
34485 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34486 PyObject *resultobj = 0;
34487 wxWindow *arg1 = (wxWindow *) 0 ;
34488 int *arg2 = (int *) 0 ;
34489 int *arg3 = (int *) 0 ;
34490 void *argp1 = 0 ;
34491 int res1 = 0 ;
34492 int temp2 ;
34493 int res2 = SWIG_TMPOBJ ;
34494 int temp3 ;
34495 int res3 = SWIG_TMPOBJ ;
34496 PyObject *swig_obj[1] ;
34497
34498 arg2 = &temp2;
34499 arg3 = &temp3;
34500 if (!args) SWIG_fail;
34501 swig_obj[0] = args;
34502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34503 if (!SWIG_IsOK(res1)) {
34504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34505 }
34506 arg1 = reinterpret_cast< wxWindow * >(argp1);
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 resultobj = SWIG_Py_Void();
34514 if (SWIG_IsTmpObj(res2)) {
34515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34516 } else {
34517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34519 }
34520 if (SWIG_IsTmpObj(res3)) {
34521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34522 } else {
34523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34525 }
34526 return resultobj;
34527 fail:
34528 return NULL;
34529 }
34530
34531
34532 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34533 PyObject *resultobj = 0;
34534 wxWindow *arg1 = (wxWindow *) 0 ;
34535 void *argp1 = 0 ;
34536 int res1 = 0 ;
34537 PyObject *swig_obj[1] ;
34538
34539 if (!args) SWIG_fail;
34540 swig_obj[0] = args;
34541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34542 if (!SWIG_IsOK(res1)) {
34543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34544 }
34545 arg1 = reinterpret_cast< wxWindow * >(argp1);
34546 {
34547 PyThreadState* __tstate = wxPyBeginAllowThreads();
34548 (arg1)->InvalidateBestSize();
34549 wxPyEndAllowThreads(__tstate);
34550 if (PyErr_Occurred()) SWIG_fail;
34551 }
34552 resultobj = SWIG_Py_Void();
34553 return resultobj;
34554 fail:
34555 return NULL;
34556 }
34557
34558
34559 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34560 PyObject *resultobj = 0;
34561 wxWindow *arg1 = (wxWindow *) 0 ;
34562 wxSize *arg2 = 0 ;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 wxSize temp2 ;
34566 PyObject * obj0 = 0 ;
34567 PyObject * obj1 = 0 ;
34568 char * kwnames[] = {
34569 (char *) "self",(char *) "size", NULL
34570 };
34571
34572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34574 if (!SWIG_IsOK(res1)) {
34575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34576 }
34577 arg1 = reinterpret_cast< wxWindow * >(argp1);
34578 {
34579 arg2 = &temp2;
34580 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34581 }
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_Py_Void();
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 wxSize result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 PyObject *swig_obj[1] ;
34602
34603 if (!args) SWIG_fail;
34604 swig_obj[0] = args;
34605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34606 if (!SWIG_IsOK(res1)) {
34607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34608 }
34609 arg1 = reinterpret_cast< wxWindow * >(argp1);
34610 {
34611 PyThreadState* __tstate = wxPyBeginAllowThreads();
34612 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34613 wxPyEndAllowThreads(__tstate);
34614 if (PyErr_Occurred()) SWIG_fail;
34615 }
34616 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34617 return resultobj;
34618 fail:
34619 return NULL;
34620 }
34621
34622
34623 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj = 0;
34625 wxWindow *arg1 = (wxWindow *) 0 ;
34626 int arg2 = (int) wxBOTH ;
34627 void *argp1 = 0 ;
34628 int res1 = 0 ;
34629 int val2 ;
34630 int ecode2 = 0 ;
34631 PyObject * obj0 = 0 ;
34632 PyObject * obj1 = 0 ;
34633 char * kwnames[] = {
34634 (char *) "self",(char *) "direction", NULL
34635 };
34636
34637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34639 if (!SWIG_IsOK(res1)) {
34640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34641 }
34642 arg1 = reinterpret_cast< wxWindow * >(argp1);
34643 if (obj1) {
34644 ecode2 = SWIG_AsVal_int(obj1, &val2);
34645 if (!SWIG_IsOK(ecode2)) {
34646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34647 }
34648 arg2 = static_cast< int >(val2);
34649 }
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 (arg1)->Center(arg2);
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 resultobj = SWIG_Py_Void();
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34664 PyObject *resultobj = 0;
34665 wxWindow *arg1 = (wxWindow *) 0 ;
34666 int arg2 = (int) wxBOTH ;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 int val2 ;
34670 int ecode2 = 0 ;
34671 PyObject * obj0 = 0 ;
34672 PyObject * obj1 = 0 ;
34673 char * kwnames[] = {
34674 (char *) "self",(char *) "dir", NULL
34675 };
34676
34677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34679 if (!SWIG_IsOK(res1)) {
34680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34681 }
34682 arg1 = reinterpret_cast< wxWindow * >(argp1);
34683 if (obj1) {
34684 ecode2 = SWIG_AsVal_int(obj1, &val2);
34685 if (!SWIG_IsOK(ecode2)) {
34686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34687 }
34688 arg2 = static_cast< int >(val2);
34689 }
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 (arg1)->CenterOnParent(arg2);
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 resultobj = SWIG_Py_Void();
34697 return resultobj;
34698 fail:
34699 return NULL;
34700 }
34701
34702
34703 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34704 PyObject *resultobj = 0;
34705 wxWindow *arg1 = (wxWindow *) 0 ;
34706 void *argp1 = 0 ;
34707 int res1 = 0 ;
34708 PyObject *swig_obj[1] ;
34709
34710 if (!args) SWIG_fail;
34711 swig_obj[0] = args;
34712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34713 if (!SWIG_IsOK(res1)) {
34714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34715 }
34716 arg1 = reinterpret_cast< wxWindow * >(argp1);
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->Fit();
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 resultobj = SWIG_Py_Void();
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 void *argp1 = 0 ;
34734 int res1 = 0 ;
34735 PyObject *swig_obj[1] ;
34736
34737 if (!args) SWIG_fail;
34738 swig_obj[0] = args;
34739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34742 }
34743 arg1 = reinterpret_cast< wxWindow * >(argp1);
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 (arg1)->FitInside();
34747 wxPyEndAllowThreads(__tstate);
34748 if (PyErr_Occurred()) SWIG_fail;
34749 }
34750 resultobj = SWIG_Py_Void();
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34758 PyObject *resultobj = 0;
34759 wxWindow *arg1 = (wxWindow *) 0 ;
34760 int arg2 ;
34761 int arg3 ;
34762 int arg4 = (int) -1 ;
34763 int arg5 = (int) -1 ;
34764 int arg6 = (int) -1 ;
34765 int arg7 = (int) -1 ;
34766 void *argp1 = 0 ;
34767 int res1 = 0 ;
34768 int val2 ;
34769 int ecode2 = 0 ;
34770 int val3 ;
34771 int ecode3 = 0 ;
34772 int val4 ;
34773 int ecode4 = 0 ;
34774 int val5 ;
34775 int ecode5 = 0 ;
34776 int val6 ;
34777 int ecode6 = 0 ;
34778 int val7 ;
34779 int ecode7 = 0 ;
34780 PyObject * obj0 = 0 ;
34781 PyObject * obj1 = 0 ;
34782 PyObject * obj2 = 0 ;
34783 PyObject * obj3 = 0 ;
34784 PyObject * obj4 = 0 ;
34785 PyObject * obj5 = 0 ;
34786 PyObject * obj6 = 0 ;
34787 char * kwnames[] = {
34788 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34789 };
34790
34791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 ecode2 = SWIG_AsVal_int(obj1, &val2);
34798 if (!SWIG_IsOK(ecode2)) {
34799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34800 }
34801 arg2 = static_cast< int >(val2);
34802 ecode3 = SWIG_AsVal_int(obj2, &val3);
34803 if (!SWIG_IsOK(ecode3)) {
34804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34805 }
34806 arg3 = static_cast< int >(val3);
34807 if (obj3) {
34808 ecode4 = SWIG_AsVal_int(obj3, &val4);
34809 if (!SWIG_IsOK(ecode4)) {
34810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34811 }
34812 arg4 = static_cast< int >(val4);
34813 }
34814 if (obj4) {
34815 ecode5 = SWIG_AsVal_int(obj4, &val5);
34816 if (!SWIG_IsOK(ecode5)) {
34817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34818 }
34819 arg5 = static_cast< int >(val5);
34820 }
34821 if (obj5) {
34822 ecode6 = SWIG_AsVal_int(obj5, &val6);
34823 if (!SWIG_IsOK(ecode6)) {
34824 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34825 }
34826 arg6 = static_cast< int >(val6);
34827 }
34828 if (obj6) {
34829 ecode7 = SWIG_AsVal_int(obj6, &val7);
34830 if (!SWIG_IsOK(ecode7)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34832 }
34833 arg7 = static_cast< int >(val7);
34834 }
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_Py_Void();
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 wxSize *arg2 = 0 ;
34852 wxSize const &arg3_defvalue = wxDefaultSize ;
34853 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34854 wxSize const &arg4_defvalue = wxDefaultSize ;
34855 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34856 void *argp1 = 0 ;
34857 int res1 = 0 ;
34858 wxSize temp2 ;
34859 wxSize temp3 ;
34860 wxSize temp4 ;
34861 PyObject * obj0 = 0 ;
34862 PyObject * obj1 = 0 ;
34863 PyObject * obj2 = 0 ;
34864 PyObject * obj3 = 0 ;
34865 char * kwnames[] = {
34866 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34867 };
34868
34869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34871 if (!SWIG_IsOK(res1)) {
34872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34873 }
34874 arg1 = reinterpret_cast< wxWindow * >(argp1);
34875 {
34876 arg2 = &temp2;
34877 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34878 }
34879 if (obj2) {
34880 {
34881 arg3 = &temp3;
34882 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34883 }
34884 }
34885 if (obj3) {
34886 {
34887 arg4 = &temp4;
34888 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34889 }
34890 }
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 resultobj = SWIG_Py_Void();
34898 return resultobj;
34899 fail:
34900 return NULL;
34901 }
34902
34903
34904 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34905 PyObject *resultobj = 0;
34906 wxWindow *arg1 = (wxWindow *) 0 ;
34907 int arg2 ;
34908 int arg3 ;
34909 int arg4 = (int) -1 ;
34910 int arg5 = (int) -1 ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 int val2 ;
34914 int ecode2 = 0 ;
34915 int val3 ;
34916 int ecode3 = 0 ;
34917 int val4 ;
34918 int ecode4 = 0 ;
34919 int val5 ;
34920 int ecode5 = 0 ;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 PyObject * obj2 = 0 ;
34924 PyObject * obj3 = 0 ;
34925 PyObject * obj4 = 0 ;
34926 char * kwnames[] = {
34927 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34928 };
34929
34930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34932 if (!SWIG_IsOK(res1)) {
34933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34934 }
34935 arg1 = reinterpret_cast< wxWindow * >(argp1);
34936 ecode2 = SWIG_AsVal_int(obj1, &val2);
34937 if (!SWIG_IsOK(ecode2)) {
34938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34939 }
34940 arg2 = static_cast< int >(val2);
34941 ecode3 = SWIG_AsVal_int(obj2, &val3);
34942 if (!SWIG_IsOK(ecode3)) {
34943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34944 }
34945 arg3 = static_cast< int >(val3);
34946 if (obj3) {
34947 ecode4 = SWIG_AsVal_int(obj3, &val4);
34948 if (!SWIG_IsOK(ecode4)) {
34949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34950 }
34951 arg4 = static_cast< int >(val4);
34952 }
34953 if (obj4) {
34954 ecode5 = SWIG_AsVal_int(obj4, &val5);
34955 if (!SWIG_IsOK(ecode5)) {
34956 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34957 }
34958 arg5 = static_cast< int >(val5);
34959 }
34960 {
34961 PyThreadState* __tstate = wxPyBeginAllowThreads();
34962 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34963 wxPyEndAllowThreads(__tstate);
34964 if (PyErr_Occurred()) SWIG_fail;
34965 }
34966 resultobj = SWIG_Py_Void();
34967 return resultobj;
34968 fail:
34969 return NULL;
34970 }
34971
34972
34973 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34974 PyObject *resultobj = 0;
34975 wxWindow *arg1 = (wxWindow *) 0 ;
34976 wxSize *arg2 = 0 ;
34977 wxSize const &arg3_defvalue = wxDefaultSize ;
34978 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34979 void *argp1 = 0 ;
34980 int res1 = 0 ;
34981 wxSize temp2 ;
34982 wxSize temp3 ;
34983 PyObject * obj0 = 0 ;
34984 PyObject * obj1 = 0 ;
34985 PyObject * obj2 = 0 ;
34986 char * kwnames[] = {
34987 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34988 };
34989
34990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34992 if (!SWIG_IsOK(res1)) {
34993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34994 }
34995 arg1 = reinterpret_cast< wxWindow * >(argp1);
34996 {
34997 arg2 = &temp2;
34998 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34999 }
35000 if (obj2) {
35001 {
35002 arg3 = &temp3;
35003 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35004 }
35005 }
35006 {
35007 PyThreadState* __tstate = wxPyBeginAllowThreads();
35008 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 resultobj = SWIG_Py_Void();
35013 return resultobj;
35014 fail:
35015 return NULL;
35016 }
35017
35018
35019 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35020 PyObject *resultobj = 0;
35021 wxWindow *arg1 = (wxWindow *) 0 ;
35022 wxSize result;
35023 void *argp1 = 0 ;
35024 int res1 = 0 ;
35025 PyObject *swig_obj[1] ;
35026
35027 if (!args) SWIG_fail;
35028 swig_obj[0] = args;
35029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35030 if (!SWIG_IsOK(res1)) {
35031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35032 }
35033 arg1 = reinterpret_cast< wxWindow * >(argp1);
35034 {
35035 PyThreadState* __tstate = wxPyBeginAllowThreads();
35036 result = ((wxWindow const *)arg1)->GetMaxSize();
35037 wxPyEndAllowThreads(__tstate);
35038 if (PyErr_Occurred()) SWIG_fail;
35039 }
35040 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35048 PyObject *resultobj = 0;
35049 wxWindow *arg1 = (wxWindow *) 0 ;
35050 wxSize result;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 PyObject *swig_obj[1] ;
35054
35055 if (!args) SWIG_fail;
35056 swig_obj[0] = args;
35057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35058 if (!SWIG_IsOK(res1)) {
35059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35060 }
35061 arg1 = reinterpret_cast< wxWindow * >(argp1);
35062 {
35063 PyThreadState* __tstate = wxPyBeginAllowThreads();
35064 result = ((wxWindow const *)arg1)->GetMinSize();
35065 wxPyEndAllowThreads(__tstate);
35066 if (PyErr_Occurred()) SWIG_fail;
35067 }
35068 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35069 return resultobj;
35070 fail:
35071 return NULL;
35072 }
35073
35074
35075 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35076 PyObject *resultobj = 0;
35077 wxWindow *arg1 = (wxWindow *) 0 ;
35078 wxSize *arg2 = 0 ;
35079 void *argp1 = 0 ;
35080 int res1 = 0 ;
35081 wxSize temp2 ;
35082 PyObject * obj0 = 0 ;
35083 PyObject * obj1 = 0 ;
35084 char * kwnames[] = {
35085 (char *) "self",(char *) "minSize", NULL
35086 };
35087
35088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35090 if (!SWIG_IsOK(res1)) {
35091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35092 }
35093 arg1 = reinterpret_cast< wxWindow * >(argp1);
35094 {
35095 arg2 = &temp2;
35096 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35097 }
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 (arg1)->SetMinSize((wxSize const &)*arg2);
35101 wxPyEndAllowThreads(__tstate);
35102 if (PyErr_Occurred()) SWIG_fail;
35103 }
35104 resultobj = SWIG_Py_Void();
35105 return resultobj;
35106 fail:
35107 return NULL;
35108 }
35109
35110
35111 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35112 PyObject *resultobj = 0;
35113 wxWindow *arg1 = (wxWindow *) 0 ;
35114 wxSize *arg2 = 0 ;
35115 void *argp1 = 0 ;
35116 int res1 = 0 ;
35117 wxSize temp2 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 char * kwnames[] = {
35121 (char *) "self",(char *) "maxSize", NULL
35122 };
35123
35124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 {
35131 arg2 = &temp2;
35132 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35133 }
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 (arg1)->SetMaxSize((wxSize const &)*arg2);
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_Py_Void();
35141 return resultobj;
35142 fail:
35143 return NULL;
35144 }
35145
35146
35147 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35148 PyObject *resultobj = 0;
35149 wxWindow *arg1 = (wxWindow *) 0 ;
35150 int result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 PyObject *swig_obj[1] ;
35154
35155 if (!args) SWIG_fail;
35156 swig_obj[0] = args;
35157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35158 if (!SWIG_IsOK(res1)) {
35159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35160 }
35161 arg1 = reinterpret_cast< wxWindow * >(argp1);
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 resultobj = SWIG_From_int(static_cast< int >(result));
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 int result;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35188 }
35189 arg1 = reinterpret_cast< wxWindow * >(argp1);
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_From_int(static_cast< int >(result));
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 int result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 resultobj = SWIG_From_int(static_cast< int >(result));
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 int result;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 PyObject *swig_obj[1] ;
35238
35239 if (!args) SWIG_fail;
35240 swig_obj[0] = args;
35241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35242 if (!SWIG_IsOK(res1)) {
35243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35244 }
35245 arg1 = reinterpret_cast< wxWindow * >(argp1);
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 resultobj = SWIG_From_int(static_cast< int >(result));
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxSize *arg2 = 0 ;
35263 void *argp1 = 0 ;
35264 int res1 = 0 ;
35265 wxSize temp2 ;
35266 PyObject * obj0 = 0 ;
35267 PyObject * obj1 = 0 ;
35268 char * kwnames[] = {
35269 (char *) "self",(char *) "size", NULL
35270 };
35271
35272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35274 if (!SWIG_IsOK(res1)) {
35275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35276 }
35277 arg1 = reinterpret_cast< wxWindow * >(argp1);
35278 {
35279 arg2 = &temp2;
35280 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35281 }
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 resultobj = SWIG_Py_Void();
35289 return resultobj;
35290 fail:
35291 return NULL;
35292 }
35293
35294
35295 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35296 PyObject *resultobj = 0;
35297 wxWindow *arg1 = (wxWindow *) 0 ;
35298 int arg2 ;
35299 int arg3 ;
35300 void *argp1 = 0 ;
35301 int res1 = 0 ;
35302 int val2 ;
35303 int ecode2 = 0 ;
35304 int val3 ;
35305 int ecode3 = 0 ;
35306 PyObject * obj0 = 0 ;
35307 PyObject * obj1 = 0 ;
35308 PyObject * obj2 = 0 ;
35309 char * kwnames[] = {
35310 (char *) "self",(char *) "w",(char *) "h", NULL
35311 };
35312
35313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35315 if (!SWIG_IsOK(res1)) {
35316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35317 }
35318 arg1 = reinterpret_cast< wxWindow * >(argp1);
35319 ecode2 = SWIG_AsVal_int(obj1, &val2);
35320 if (!SWIG_IsOK(ecode2)) {
35321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35322 }
35323 arg2 = static_cast< int >(val2);
35324 ecode3 = SWIG_AsVal_int(obj2, &val3);
35325 if (!SWIG_IsOK(ecode3)) {
35326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35327 }
35328 arg3 = static_cast< int >(val3);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 (arg1)->SetVirtualSize(arg2,arg3);
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_Py_Void();
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 wxSize result;
35346 void *argp1 = 0 ;
35347 int res1 = 0 ;
35348 PyObject *swig_obj[1] ;
35349
35350 if (!args) SWIG_fail;
35351 swig_obj[0] = args;
35352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35353 if (!SWIG_IsOK(res1)) {
35354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35355 }
35356 arg1 = reinterpret_cast< wxWindow * >(argp1);
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 result = ((wxWindow const *)arg1)->GetVirtualSize();
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35364 return resultobj;
35365 fail:
35366 return NULL;
35367 }
35368
35369
35370 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35371 PyObject *resultobj = 0;
35372 wxWindow *arg1 = (wxWindow *) 0 ;
35373 int *arg2 = (int *) 0 ;
35374 int *arg3 = (int *) 0 ;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 int temp2 ;
35378 int res2 = SWIG_TMPOBJ ;
35379 int temp3 ;
35380 int res3 = SWIG_TMPOBJ ;
35381 PyObject *swig_obj[1] ;
35382
35383 arg2 = &temp2;
35384 arg3 = &temp3;
35385 if (!args) SWIG_fail;
35386 swig_obj[0] = args;
35387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35388 if (!SWIG_IsOK(res1)) {
35389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35390 }
35391 arg1 = reinterpret_cast< wxWindow * >(argp1);
35392 {
35393 PyThreadState* __tstate = wxPyBeginAllowThreads();
35394 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35395 wxPyEndAllowThreads(__tstate);
35396 if (PyErr_Occurred()) SWIG_fail;
35397 }
35398 resultobj = SWIG_Py_Void();
35399 if (SWIG_IsTmpObj(res2)) {
35400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35401 } else {
35402 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35404 }
35405 if (SWIG_IsTmpObj(res3)) {
35406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35407 } else {
35408 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35410 }
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35418 PyObject *resultobj = 0;
35419 wxWindow *arg1 = (wxWindow *) 0 ;
35420 wxSize result;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 PyObject *swig_obj[1] ;
35424
35425 if (!args) SWIG_fail;
35426 swig_obj[0] = args;
35427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35430 }
35431 arg1 = reinterpret_cast< wxWindow * >(argp1);
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35439 return resultobj;
35440 fail:
35441 return NULL;
35442 }
35443
35444
35445 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35446 PyObject *resultobj = 0;
35447 wxWindow *arg1 = (wxWindow *) 0 ;
35448 bool arg2 = (bool) true ;
35449 bool result;
35450 void *argp1 = 0 ;
35451 int res1 = 0 ;
35452 bool val2 ;
35453 int ecode2 = 0 ;
35454 PyObject * obj0 = 0 ;
35455 PyObject * obj1 = 0 ;
35456 char * kwnames[] = {
35457 (char *) "self",(char *) "show", NULL
35458 };
35459
35460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35462 if (!SWIG_IsOK(res1)) {
35463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35464 }
35465 arg1 = reinterpret_cast< wxWindow * >(argp1);
35466 if (obj1) {
35467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35468 if (!SWIG_IsOK(ecode2)) {
35469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35470 }
35471 arg2 = static_cast< bool >(val2);
35472 }
35473 {
35474 PyThreadState* __tstate = wxPyBeginAllowThreads();
35475 result = (bool)(arg1)->Show(arg2);
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 {
35480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35481 }
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35489 PyObject *resultobj = 0;
35490 wxWindow *arg1 = (wxWindow *) 0 ;
35491 bool result;
35492 void *argp1 = 0 ;
35493 int res1 = 0 ;
35494 PyObject *swig_obj[1] ;
35495
35496 if (!args) SWIG_fail;
35497 swig_obj[0] = args;
35498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35499 if (!SWIG_IsOK(res1)) {
35500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35501 }
35502 arg1 = reinterpret_cast< wxWindow * >(argp1);
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 result = (bool)(arg1)->Hide();
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 {
35510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35511 }
35512 return resultobj;
35513 fail:
35514 return NULL;
35515 }
35516
35517
35518 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35519 PyObject *resultobj = 0;
35520 wxWindow *arg1 = (wxWindow *) 0 ;
35521 bool arg2 = (bool) true ;
35522 bool result;
35523 void *argp1 = 0 ;
35524 int res1 = 0 ;
35525 bool val2 ;
35526 int ecode2 = 0 ;
35527 PyObject * obj0 = 0 ;
35528 PyObject * obj1 = 0 ;
35529 char * kwnames[] = {
35530 (char *) "self",(char *) "enable", NULL
35531 };
35532
35533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35537 }
35538 arg1 = reinterpret_cast< wxWindow * >(argp1);
35539 if (obj1) {
35540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35541 if (!SWIG_IsOK(ecode2)) {
35542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35543 }
35544 arg2 = static_cast< bool >(val2);
35545 }
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 result = (bool)(arg1)->Enable(arg2);
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 {
35553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35554 }
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35562 PyObject *resultobj = 0;
35563 wxWindow *arg1 = (wxWindow *) 0 ;
35564 bool result;
35565 void *argp1 = 0 ;
35566 int res1 = 0 ;
35567 PyObject *swig_obj[1] ;
35568
35569 if (!args) SWIG_fail;
35570 swig_obj[0] = args;
35571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35572 if (!SWIG_IsOK(res1)) {
35573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35574 }
35575 arg1 = reinterpret_cast< wxWindow * >(argp1);
35576 {
35577 PyThreadState* __tstate = wxPyBeginAllowThreads();
35578 result = (bool)(arg1)->Disable();
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 {
35583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35584 }
35585 return resultobj;
35586 fail:
35587 return NULL;
35588 }
35589
35590
35591 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35592 PyObject *resultobj = 0;
35593 wxWindow *arg1 = (wxWindow *) 0 ;
35594 bool result;
35595 void *argp1 = 0 ;
35596 int res1 = 0 ;
35597 PyObject *swig_obj[1] ;
35598
35599 if (!args) SWIG_fail;
35600 swig_obj[0] = args;
35601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35602 if (!SWIG_IsOK(res1)) {
35603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35604 }
35605 arg1 = reinterpret_cast< wxWindow * >(argp1);
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 result = (bool)((wxWindow const *)arg1)->IsShown();
35609 wxPyEndAllowThreads(__tstate);
35610 if (PyErr_Occurred()) SWIG_fail;
35611 }
35612 {
35613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35614 }
35615 return resultobj;
35616 fail:
35617 return NULL;
35618 }
35619
35620
35621 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35622 PyObject *resultobj = 0;
35623 wxWindow *arg1 = (wxWindow *) 0 ;
35624 bool result;
35625 void *argp1 = 0 ;
35626 int res1 = 0 ;
35627 PyObject *swig_obj[1] ;
35628
35629 if (!args) SWIG_fail;
35630 swig_obj[0] = args;
35631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35632 if (!SWIG_IsOK(res1)) {
35633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35634 }
35635 arg1 = reinterpret_cast< wxWindow * >(argp1);
35636 {
35637 PyThreadState* __tstate = wxPyBeginAllowThreads();
35638 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35639 wxPyEndAllowThreads(__tstate);
35640 if (PyErr_Occurred()) SWIG_fail;
35641 }
35642 {
35643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35644 }
35645 return resultobj;
35646 fail:
35647 return NULL;
35648 }
35649
35650
35651 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35652 PyObject *resultobj = 0;
35653 wxWindow *arg1 = (wxWindow *) 0 ;
35654 bool result;
35655 void *argp1 = 0 ;
35656 int res1 = 0 ;
35657 PyObject *swig_obj[1] ;
35658
35659 if (!args) SWIG_fail;
35660 swig_obj[0] = args;
35661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35662 if (!SWIG_IsOK(res1)) {
35663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35664 }
35665 arg1 = reinterpret_cast< wxWindow * >(argp1);
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 {
35673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35674 }
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35682 PyObject *resultobj = 0;
35683 wxWindow *arg1 = (wxWindow *) 0 ;
35684 long arg2 ;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 long val2 ;
35688 int ecode2 = 0 ;
35689 PyObject * obj0 = 0 ;
35690 PyObject * obj1 = 0 ;
35691 char * kwnames[] = {
35692 (char *) "self",(char *) "style", NULL
35693 };
35694
35695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35697 if (!SWIG_IsOK(res1)) {
35698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35699 }
35700 arg1 = reinterpret_cast< wxWindow * >(argp1);
35701 ecode2 = SWIG_AsVal_long(obj1, &val2);
35702 if (!SWIG_IsOK(ecode2)) {
35703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35704 }
35705 arg2 = static_cast< long >(val2);
35706 {
35707 PyThreadState* __tstate = wxPyBeginAllowThreads();
35708 (arg1)->SetWindowStyleFlag(arg2);
35709 wxPyEndAllowThreads(__tstate);
35710 if (PyErr_Occurred()) SWIG_fail;
35711 }
35712 resultobj = SWIG_Py_Void();
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35720 PyObject *resultobj = 0;
35721 wxWindow *arg1 = (wxWindow *) 0 ;
35722 long result;
35723 void *argp1 = 0 ;
35724 int res1 = 0 ;
35725 PyObject *swig_obj[1] ;
35726
35727 if (!args) SWIG_fail;
35728 swig_obj[0] = args;
35729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35730 if (!SWIG_IsOK(res1)) {
35731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35732 }
35733 arg1 = reinterpret_cast< wxWindow * >(argp1);
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_From_long(static_cast< long >(result));
35741 return resultobj;
35742 fail:
35743 return NULL;
35744 }
35745
35746
35747 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35748 PyObject *resultobj = 0;
35749 wxWindow *arg1 = (wxWindow *) 0 ;
35750 int arg2 ;
35751 bool result;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 int val2 ;
35755 int ecode2 = 0 ;
35756 PyObject * obj0 = 0 ;
35757 PyObject * obj1 = 0 ;
35758 char * kwnames[] = {
35759 (char *) "self",(char *) "flag", NULL
35760 };
35761
35762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35764 if (!SWIG_IsOK(res1)) {
35765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35766 }
35767 arg1 = reinterpret_cast< wxWindow * >(argp1);
35768 ecode2 = SWIG_AsVal_int(obj1, &val2);
35769 if (!SWIG_IsOK(ecode2)) {
35770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35771 }
35772 arg2 = static_cast< int >(val2);
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 {
35780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35781 }
35782 return resultobj;
35783 fail:
35784 return NULL;
35785 }
35786
35787
35788 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35789 PyObject *resultobj = 0;
35790 wxWindow *arg1 = (wxWindow *) 0 ;
35791 bool result;
35792 void *argp1 = 0 ;
35793 int res1 = 0 ;
35794 PyObject *swig_obj[1] ;
35795
35796 if (!args) SWIG_fail;
35797 swig_obj[0] = args;
35798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35799 if (!SWIG_IsOK(res1)) {
35800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35801 }
35802 arg1 = reinterpret_cast< wxWindow * >(argp1);
35803 {
35804 PyThreadState* __tstate = wxPyBeginAllowThreads();
35805 result = (bool)((wxWindow const *)arg1)->IsRetained();
35806 wxPyEndAllowThreads(__tstate);
35807 if (PyErr_Occurred()) SWIG_fail;
35808 }
35809 {
35810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35811 }
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35819 PyObject *resultobj = 0;
35820 wxWindow *arg1 = (wxWindow *) 0 ;
35821 long arg2 ;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824 long val2 ;
35825 int ecode2 = 0 ;
35826 PyObject * obj0 = 0 ;
35827 PyObject * obj1 = 0 ;
35828 char * kwnames[] = {
35829 (char *) "self",(char *) "exStyle", NULL
35830 };
35831
35832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35834 if (!SWIG_IsOK(res1)) {
35835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35836 }
35837 arg1 = reinterpret_cast< wxWindow * >(argp1);
35838 ecode2 = SWIG_AsVal_long(obj1, &val2);
35839 if (!SWIG_IsOK(ecode2)) {
35840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35841 }
35842 arg2 = static_cast< long >(val2);
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 (arg1)->SetExtraStyle(arg2);
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_Py_Void();
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 long result;
35860 void *argp1 = 0 ;
35861 int res1 = 0 ;
35862 PyObject *swig_obj[1] ;
35863
35864 if (!args) SWIG_fail;
35865 swig_obj[0] = args;
35866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35867 if (!SWIG_IsOK(res1)) {
35868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35869 }
35870 arg1 = reinterpret_cast< wxWindow * >(argp1);
35871 {
35872 PyThreadState* __tstate = wxPyBeginAllowThreads();
35873 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35874 wxPyEndAllowThreads(__tstate);
35875 if (PyErr_Occurred()) SWIG_fail;
35876 }
35877 resultobj = SWIG_From_long(static_cast< long >(result));
35878 return resultobj;
35879 fail:
35880 return NULL;
35881 }
35882
35883
35884 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35885 PyObject *resultobj = 0;
35886 wxWindow *arg1 = (wxWindow *) 0 ;
35887 bool arg2 = (bool) true ;
35888 void *argp1 = 0 ;
35889 int res1 = 0 ;
35890 bool val2 ;
35891 int ecode2 = 0 ;
35892 PyObject * obj0 = 0 ;
35893 PyObject * obj1 = 0 ;
35894 char * kwnames[] = {
35895 (char *) "self",(char *) "modal", NULL
35896 };
35897
35898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35902 }
35903 arg1 = reinterpret_cast< wxWindow * >(argp1);
35904 if (obj1) {
35905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35906 if (!SWIG_IsOK(ecode2)) {
35907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35908 }
35909 arg2 = static_cast< bool >(val2);
35910 }
35911 {
35912 PyThreadState* __tstate = wxPyBeginAllowThreads();
35913 (arg1)->MakeModal(arg2);
35914 wxPyEndAllowThreads(__tstate);
35915 if (PyErr_Occurred()) SWIG_fail;
35916 }
35917 resultobj = SWIG_Py_Void();
35918 return resultobj;
35919 fail:
35920 return NULL;
35921 }
35922
35923
35924 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35925 PyObject *resultobj = 0;
35926 wxWindow *arg1 = (wxWindow *) 0 ;
35927 bool arg2 ;
35928 void *argp1 = 0 ;
35929 int res1 = 0 ;
35930 bool val2 ;
35931 int ecode2 = 0 ;
35932 PyObject * obj0 = 0 ;
35933 PyObject * obj1 = 0 ;
35934 char * kwnames[] = {
35935 (char *) "self",(char *) "enableTheme", NULL
35936 };
35937
35938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35940 if (!SWIG_IsOK(res1)) {
35941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35942 }
35943 arg1 = reinterpret_cast< wxWindow * >(argp1);
35944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35945 if (!SWIG_IsOK(ecode2)) {
35946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35947 }
35948 arg2 = static_cast< bool >(val2);
35949 {
35950 PyThreadState* __tstate = wxPyBeginAllowThreads();
35951 (arg1)->SetThemeEnabled(arg2);
35952 wxPyEndAllowThreads(__tstate);
35953 if (PyErr_Occurred()) SWIG_fail;
35954 }
35955 resultobj = SWIG_Py_Void();
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35963 PyObject *resultobj = 0;
35964 wxWindow *arg1 = (wxWindow *) 0 ;
35965 bool result;
35966 void *argp1 = 0 ;
35967 int res1 = 0 ;
35968 PyObject *swig_obj[1] ;
35969
35970 if (!args) SWIG_fail;
35971 swig_obj[0] = args;
35972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35973 if (!SWIG_IsOK(res1)) {
35974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35975 }
35976 arg1 = reinterpret_cast< wxWindow * >(argp1);
35977 {
35978 PyThreadState* __tstate = wxPyBeginAllowThreads();
35979 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35980 wxPyEndAllowThreads(__tstate);
35981 if (PyErr_Occurred()) SWIG_fail;
35982 }
35983 {
35984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35985 }
35986 return resultobj;
35987 fail:
35988 return NULL;
35989 }
35990
35991
35992 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35993 PyObject *resultobj = 0;
35994 wxWindow *arg1 = (wxWindow *) 0 ;
35995 void *argp1 = 0 ;
35996 int res1 = 0 ;
35997 PyObject *swig_obj[1] ;
35998
35999 if (!args) SWIG_fail;
36000 swig_obj[0] = args;
36001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36002 if (!SWIG_IsOK(res1)) {
36003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36004 }
36005 arg1 = reinterpret_cast< wxWindow * >(argp1);
36006 {
36007 PyThreadState* __tstate = wxPyBeginAllowThreads();
36008 (arg1)->SetFocus();
36009 wxPyEndAllowThreads(__tstate);
36010 if (PyErr_Occurred()) SWIG_fail;
36011 }
36012 resultobj = SWIG_Py_Void();
36013 return resultobj;
36014 fail:
36015 return NULL;
36016 }
36017
36018
36019 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36020 PyObject *resultobj = 0;
36021 wxWindow *arg1 = (wxWindow *) 0 ;
36022 void *argp1 = 0 ;
36023 int res1 = 0 ;
36024 PyObject *swig_obj[1] ;
36025
36026 if (!args) SWIG_fail;
36027 swig_obj[0] = args;
36028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36029 if (!SWIG_IsOK(res1)) {
36030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36031 }
36032 arg1 = reinterpret_cast< wxWindow * >(argp1);
36033 {
36034 PyThreadState* __tstate = wxPyBeginAllowThreads();
36035 (arg1)->SetFocusFromKbd();
36036 wxPyEndAllowThreads(__tstate);
36037 if (PyErr_Occurred()) SWIG_fail;
36038 }
36039 resultobj = SWIG_Py_Void();
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxWindow *result = 0 ;
36049
36050 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36051 {
36052 if (!wxPyCheckForApp()) SWIG_fail;
36053 PyThreadState* __tstate = wxPyBeginAllowThreads();
36054 result = (wxWindow *)wxWindow::FindFocus();
36055 wxPyEndAllowThreads(__tstate);
36056 if (PyErr_Occurred()) SWIG_fail;
36057 }
36058 {
36059 resultobj = wxPyMake_wxObject(result, 0);
36060 }
36061 return resultobj;
36062 fail:
36063 return NULL;
36064 }
36065
36066
36067 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36068 PyObject *resultobj = 0;
36069 wxWindow *arg1 = (wxWindow *) 0 ;
36070 bool result;
36071 void *argp1 = 0 ;
36072 int res1 = 0 ;
36073 PyObject *swig_obj[1] ;
36074
36075 if (!args) SWIG_fail;
36076 swig_obj[0] = args;
36077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36078 if (!SWIG_IsOK(res1)) {
36079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36080 }
36081 arg1 = reinterpret_cast< wxWindow * >(argp1);
36082 {
36083 PyThreadState* __tstate = wxPyBeginAllowThreads();
36084 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36085 wxPyEndAllowThreads(__tstate);
36086 if (PyErr_Occurred()) SWIG_fail;
36087 }
36088 {
36089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36090 }
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 bool result;
36101 void *argp1 = 0 ;
36102 int res1 = 0 ;
36103 PyObject *swig_obj[1] ;
36104
36105 if (!args) SWIG_fail;
36106 swig_obj[0] = args;
36107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36108 if (!SWIG_IsOK(res1)) {
36109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36110 }
36111 arg1 = reinterpret_cast< wxWindow * >(argp1);
36112 {
36113 PyThreadState* __tstate = wxPyBeginAllowThreads();
36114 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36115 wxPyEndAllowThreads(__tstate);
36116 if (PyErr_Occurred()) SWIG_fail;
36117 }
36118 {
36119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36120 }
36121 return resultobj;
36122 fail:
36123 return NULL;
36124 }
36125
36126
36127 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36128 PyObject *resultobj = 0;
36129 wxWindow *arg1 = (wxWindow *) 0 ;
36130 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36131 bool result;
36132 void *argp1 = 0 ;
36133 int res1 = 0 ;
36134 int val2 ;
36135 int ecode2 = 0 ;
36136 PyObject * obj0 = 0 ;
36137 PyObject * obj1 = 0 ;
36138 char * kwnames[] = {
36139 (char *) "self",(char *) "flags", NULL
36140 };
36141
36142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36144 if (!SWIG_IsOK(res1)) {
36145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36146 }
36147 arg1 = reinterpret_cast< wxWindow * >(argp1);
36148 if (obj1) {
36149 ecode2 = SWIG_AsVal_int(obj1, &val2);
36150 if (!SWIG_IsOK(ecode2)) {
36151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36152 }
36153 arg2 = static_cast< int >(val2);
36154 }
36155 {
36156 PyThreadState* __tstate = wxPyBeginAllowThreads();
36157 result = (bool)(arg1)->Navigate(arg2);
36158 wxPyEndAllowThreads(__tstate);
36159 if (PyErr_Occurred()) SWIG_fail;
36160 }
36161 {
36162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36163 }
36164 return resultobj;
36165 fail:
36166 return NULL;
36167 }
36168
36169
36170 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36171 PyObject *resultobj = 0;
36172 wxWindow *arg1 = (wxWindow *) 0 ;
36173 wxWindow *arg2 = (wxWindow *) 0 ;
36174 void *argp1 = 0 ;
36175 int res1 = 0 ;
36176 void *argp2 = 0 ;
36177 int res2 = 0 ;
36178 PyObject * obj0 = 0 ;
36179 PyObject * obj1 = 0 ;
36180 char * kwnames[] = {
36181 (char *) "self",(char *) "win", NULL
36182 };
36183
36184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36186 if (!SWIG_IsOK(res1)) {
36187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36188 }
36189 arg1 = reinterpret_cast< wxWindow * >(argp1);
36190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36191 if (!SWIG_IsOK(res2)) {
36192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36193 }
36194 arg2 = reinterpret_cast< wxWindow * >(argp2);
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 (arg1)->MoveAfterInTabOrder(arg2);
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 resultobj = SWIG_Py_Void();
36202 return resultobj;
36203 fail:
36204 return NULL;
36205 }
36206
36207
36208 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36209 PyObject *resultobj = 0;
36210 wxWindow *arg1 = (wxWindow *) 0 ;
36211 wxWindow *arg2 = (wxWindow *) 0 ;
36212 void *argp1 = 0 ;
36213 int res1 = 0 ;
36214 void *argp2 = 0 ;
36215 int res2 = 0 ;
36216 PyObject * obj0 = 0 ;
36217 PyObject * obj1 = 0 ;
36218 char * kwnames[] = {
36219 (char *) "self",(char *) "win", NULL
36220 };
36221
36222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36224 if (!SWIG_IsOK(res1)) {
36225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36226 }
36227 arg1 = reinterpret_cast< wxWindow * >(argp1);
36228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36229 if (!SWIG_IsOK(res2)) {
36230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36231 }
36232 arg2 = reinterpret_cast< wxWindow * >(argp2);
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 (arg1)->MoveBeforeInTabOrder(arg2);
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 resultobj = SWIG_Py_Void();
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36247 PyObject *resultobj = 0;
36248 wxWindow *arg1 = (wxWindow *) 0 ;
36249 PyObject *result = 0 ;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 PyObject *swig_obj[1] ;
36253
36254 if (!args) SWIG_fail;
36255 swig_obj[0] = args;
36256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (PyObject *)wxWindow_GetChildren(arg1);
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 resultobj = result;
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36275 PyObject *resultobj = 0;
36276 wxWindow *arg1 = (wxWindow *) 0 ;
36277 wxWindow *result = 0 ;
36278 void *argp1 = 0 ;
36279 int res1 = 0 ;
36280 PyObject *swig_obj[1] ;
36281
36282 if (!args) SWIG_fail;
36283 swig_obj[0] = args;
36284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36285 if (!SWIG_IsOK(res1)) {
36286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36287 }
36288 arg1 = reinterpret_cast< wxWindow * >(argp1);
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36292 wxPyEndAllowThreads(__tstate);
36293 if (PyErr_Occurred()) SWIG_fail;
36294 }
36295 {
36296 resultobj = wxPyMake_wxObject(result, 0);
36297 }
36298 return resultobj;
36299 fail:
36300 return NULL;
36301 }
36302
36303
36304 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36305 PyObject *resultobj = 0;
36306 wxWindow *arg1 = (wxWindow *) 0 ;
36307 wxWindow *result = 0 ;
36308 void *argp1 = 0 ;
36309 int res1 = 0 ;
36310 PyObject *swig_obj[1] ;
36311
36312 if (!args) SWIG_fail;
36313 swig_obj[0] = args;
36314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36315 if (!SWIG_IsOK(res1)) {
36316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36317 }
36318 arg1 = reinterpret_cast< wxWindow * >(argp1);
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36322 wxPyEndAllowThreads(__tstate);
36323 if (PyErr_Occurred()) SWIG_fail;
36324 }
36325 {
36326 resultobj = wxPyMake_wxObject(result, 0);
36327 }
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 bool result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36347 }
36348 arg1 = reinterpret_cast< wxWindow * >(argp1);
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 {
36356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36357 }
36358 return resultobj;
36359 fail:
36360 return NULL;
36361 }
36362
36363
36364 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36365 PyObject *resultobj = 0;
36366 wxWindow *arg1 = (wxWindow *) 0 ;
36367 wxWindow *arg2 = (wxWindow *) 0 ;
36368 bool result;
36369 void *argp1 = 0 ;
36370 int res1 = 0 ;
36371 void *argp2 = 0 ;
36372 int res2 = 0 ;
36373 PyObject * obj0 = 0 ;
36374 PyObject * obj1 = 0 ;
36375 char * kwnames[] = {
36376 (char *) "self",(char *) "newParent", NULL
36377 };
36378
36379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36381 if (!SWIG_IsOK(res1)) {
36382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36383 }
36384 arg1 = reinterpret_cast< wxWindow * >(argp1);
36385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36386 if (!SWIG_IsOK(res2)) {
36387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36388 }
36389 arg2 = reinterpret_cast< wxWindow * >(argp2);
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 result = (bool)(arg1)->Reparent(arg2);
36393 wxPyEndAllowThreads(__tstate);
36394 if (PyErr_Occurred()) SWIG_fail;
36395 }
36396 {
36397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36398 }
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36406 PyObject *resultobj = 0;
36407 wxWindow *arg1 = (wxWindow *) 0 ;
36408 wxWindow *arg2 = (wxWindow *) 0 ;
36409 void *argp1 = 0 ;
36410 int res1 = 0 ;
36411 void *argp2 = 0 ;
36412 int res2 = 0 ;
36413 PyObject * obj0 = 0 ;
36414 PyObject * obj1 = 0 ;
36415 char * kwnames[] = {
36416 (char *) "self",(char *) "child", NULL
36417 };
36418
36419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36421 if (!SWIG_IsOK(res1)) {
36422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36423 }
36424 arg1 = reinterpret_cast< wxWindow * >(argp1);
36425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36426 if (!SWIG_IsOK(res2)) {
36427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36428 }
36429 arg2 = reinterpret_cast< wxWindow * >(argp2);
36430 {
36431 PyThreadState* __tstate = wxPyBeginAllowThreads();
36432 (arg1)->AddChild(arg2);
36433 wxPyEndAllowThreads(__tstate);
36434 if (PyErr_Occurred()) SWIG_fail;
36435 }
36436 resultobj = SWIG_Py_Void();
36437 return resultobj;
36438 fail:
36439 return NULL;
36440 }
36441
36442
36443 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36444 PyObject *resultobj = 0;
36445 wxWindow *arg1 = (wxWindow *) 0 ;
36446 wxWindow *arg2 = (wxWindow *) 0 ;
36447 void *argp1 = 0 ;
36448 int res1 = 0 ;
36449 void *argp2 = 0 ;
36450 int res2 = 0 ;
36451 PyObject * obj0 = 0 ;
36452 PyObject * obj1 = 0 ;
36453 char * kwnames[] = {
36454 (char *) "self",(char *) "child", NULL
36455 };
36456
36457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36459 if (!SWIG_IsOK(res1)) {
36460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36461 }
36462 arg1 = reinterpret_cast< wxWindow * >(argp1);
36463 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36464 if (!SWIG_IsOK(res2)) {
36465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36466 }
36467 arg2 = reinterpret_cast< wxWindow * >(argp2);
36468 {
36469 PyThreadState* __tstate = wxPyBeginAllowThreads();
36470 (arg1)->RemoveChild(arg2);
36471 wxPyEndAllowThreads(__tstate);
36472 if (PyErr_Occurred()) SWIG_fail;
36473 }
36474 resultobj = SWIG_Py_Void();
36475 return resultobj;
36476 fail:
36477 return NULL;
36478 }
36479
36480
36481 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36482 PyObject *resultobj = 0;
36483 wxWindow *arg1 = (wxWindow *) 0 ;
36484 bool arg2 ;
36485 void *argp1 = 0 ;
36486 int res1 = 0 ;
36487 bool val2 ;
36488 int ecode2 = 0 ;
36489 PyObject * obj0 = 0 ;
36490 PyObject * obj1 = 0 ;
36491 char * kwnames[] = {
36492 (char *) "self",(char *) "on", NULL
36493 };
36494
36495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36497 if (!SWIG_IsOK(res1)) {
36498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36499 }
36500 arg1 = reinterpret_cast< wxWindow * >(argp1);
36501 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36502 if (!SWIG_IsOK(ecode2)) {
36503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36504 }
36505 arg2 = static_cast< bool >(val2);
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 wxWindow_SetDoubleBuffered(arg1,arg2);
36509 wxPyEndAllowThreads(__tstate);
36510 if (PyErr_Occurred()) SWIG_fail;
36511 }
36512 resultobj = SWIG_Py_Void();
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36520 PyObject *resultobj = 0;
36521 wxWindow *arg1 = (wxWindow *) 0 ;
36522 long arg2 ;
36523 wxWindow *result = 0 ;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 long val2 ;
36527 int ecode2 = 0 ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "winid", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 ecode2 = SWIG_AsVal_long(obj1, &val2);
36541 if (!SWIG_IsOK(ecode2)) {
36542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36543 }
36544 arg2 = static_cast< long >(val2);
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 result = (wxWindow *)(arg1)->FindWindow(arg2);
36548 wxPyEndAllowThreads(__tstate);
36549 if (PyErr_Occurred()) SWIG_fail;
36550 }
36551 {
36552 resultobj = wxPyMake_wxObject(result, 0);
36553 }
36554 return resultobj;
36555 fail:
36556 return NULL;
36557 }
36558
36559
36560 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36561 PyObject *resultobj = 0;
36562 wxWindow *arg1 = (wxWindow *) 0 ;
36563 wxString *arg2 = 0 ;
36564 wxWindow *result = 0 ;
36565 void *argp1 = 0 ;
36566 int res1 = 0 ;
36567 bool temp2 = false ;
36568 PyObject * obj0 = 0 ;
36569 PyObject * obj1 = 0 ;
36570 char * kwnames[] = {
36571 (char *) "self",(char *) "name", NULL
36572 };
36573
36574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 {
36581 arg2 = wxString_in_helper(obj1);
36582 if (arg2 == NULL) SWIG_fail;
36583 temp2 = true;
36584 }
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 {
36592 resultobj = wxPyMake_wxObject(result, 0);
36593 }
36594 {
36595 if (temp2)
36596 delete arg2;
36597 }
36598 return resultobj;
36599 fail:
36600 {
36601 if (temp2)
36602 delete arg2;
36603 }
36604 return NULL;
36605 }
36606
36607
36608 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36609 PyObject *resultobj = 0;
36610 wxWindow *arg1 = (wxWindow *) 0 ;
36611 wxEvtHandler *result = 0 ;
36612 void *argp1 = 0 ;
36613 int res1 = 0 ;
36614 PyObject *swig_obj[1] ;
36615
36616 if (!args) SWIG_fail;
36617 swig_obj[0] = args;
36618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36619 if (!SWIG_IsOK(res1)) {
36620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36621 }
36622 arg1 = reinterpret_cast< wxWindow * >(argp1);
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36626 wxPyEndAllowThreads(__tstate);
36627 if (PyErr_Occurred()) SWIG_fail;
36628 }
36629 {
36630 resultobj = wxPyMake_wxObject(result, 0);
36631 }
36632 return resultobj;
36633 fail:
36634 return NULL;
36635 }
36636
36637
36638 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36639 PyObject *resultobj = 0;
36640 wxWindow *arg1 = (wxWindow *) 0 ;
36641 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36642 void *argp1 = 0 ;
36643 int res1 = 0 ;
36644 void *argp2 = 0 ;
36645 int res2 = 0 ;
36646 PyObject * obj0 = 0 ;
36647 PyObject * obj1 = 0 ;
36648 char * kwnames[] = {
36649 (char *) "self",(char *) "handler", NULL
36650 };
36651
36652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36654 if (!SWIG_IsOK(res1)) {
36655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36656 }
36657 arg1 = reinterpret_cast< wxWindow * >(argp1);
36658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36659 if (!SWIG_IsOK(res2)) {
36660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36661 }
36662 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 (arg1)->SetEventHandler(arg2);
36666 wxPyEndAllowThreads(__tstate);
36667 if (PyErr_Occurred()) SWIG_fail;
36668 }
36669 resultobj = SWIG_Py_Void();
36670 return resultobj;
36671 fail:
36672 return NULL;
36673 }
36674
36675
36676 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj = 0;
36678 wxWindow *arg1 = (wxWindow *) 0 ;
36679 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 void *argp2 = 0 ;
36683 int res2 = 0 ;
36684 PyObject * obj0 = 0 ;
36685 PyObject * obj1 = 0 ;
36686 char * kwnames[] = {
36687 (char *) "self",(char *) "handler", NULL
36688 };
36689
36690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36692 if (!SWIG_IsOK(res1)) {
36693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36694 }
36695 arg1 = reinterpret_cast< wxWindow * >(argp1);
36696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36697 if (!SWIG_IsOK(res2)) {
36698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36699 }
36700 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 (arg1)->PushEventHandler(arg2);
36704 wxPyEndAllowThreads(__tstate);
36705 if (PyErr_Occurred()) SWIG_fail;
36706 }
36707 resultobj = SWIG_Py_Void();
36708 return resultobj;
36709 fail:
36710 return NULL;
36711 }
36712
36713
36714 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36715 PyObject *resultobj = 0;
36716 wxWindow *arg1 = (wxWindow *) 0 ;
36717 bool arg2 = (bool) false ;
36718 wxEvtHandler *result = 0 ;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 bool val2 ;
36722 int ecode2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char * kwnames[] = {
36726 (char *) "self",(char *) "deleteHandler", NULL
36727 };
36728
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 if (obj1) {
36736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36737 if (!SWIG_IsOK(ecode2)) {
36738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36739 }
36740 arg2 = static_cast< bool >(val2);
36741 }
36742 {
36743 PyThreadState* __tstate = wxPyBeginAllowThreads();
36744 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36745 wxPyEndAllowThreads(__tstate);
36746 if (PyErr_Occurred()) SWIG_fail;
36747 }
36748 {
36749 resultobj = wxPyMake_wxObject(result, 0);
36750 }
36751 return resultobj;
36752 fail:
36753 return NULL;
36754 }
36755
36756
36757 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36758 PyObject *resultobj = 0;
36759 wxWindow *arg1 = (wxWindow *) 0 ;
36760 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36761 bool result;
36762 void *argp1 = 0 ;
36763 int res1 = 0 ;
36764 void *argp2 = 0 ;
36765 int res2 = 0 ;
36766 PyObject * obj0 = 0 ;
36767 PyObject * obj1 = 0 ;
36768 char * kwnames[] = {
36769 (char *) "self",(char *) "handler", NULL
36770 };
36771
36772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36774 if (!SWIG_IsOK(res1)) {
36775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36776 }
36777 arg1 = reinterpret_cast< wxWindow * >(argp1);
36778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36779 if (!SWIG_IsOK(res2)) {
36780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36781 }
36782 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36783 {
36784 PyThreadState* __tstate = wxPyBeginAllowThreads();
36785 result = (bool)(arg1)->RemoveEventHandler(arg2);
36786 wxPyEndAllowThreads(__tstate);
36787 if (PyErr_Occurred()) SWIG_fail;
36788 }
36789 {
36790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36791 }
36792 return resultobj;
36793 fail:
36794 return NULL;
36795 }
36796
36797
36798 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36799 PyObject *resultobj = 0;
36800 wxWindow *arg1 = (wxWindow *) 0 ;
36801 wxValidator *arg2 = 0 ;
36802 void *argp1 = 0 ;
36803 int res1 = 0 ;
36804 void *argp2 = 0 ;
36805 int res2 = 0 ;
36806 PyObject * obj0 = 0 ;
36807 PyObject * obj1 = 0 ;
36808 char * kwnames[] = {
36809 (char *) "self",(char *) "validator", NULL
36810 };
36811
36812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36814 if (!SWIG_IsOK(res1)) {
36815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36816 }
36817 arg1 = reinterpret_cast< wxWindow * >(argp1);
36818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36819 if (!SWIG_IsOK(res2)) {
36820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36821 }
36822 if (!argp2) {
36823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36824 }
36825 arg2 = reinterpret_cast< wxValidator * >(argp2);
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 (arg1)->SetValidator((wxValidator const &)*arg2);
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 resultobj = SWIG_Py_Void();
36833 return resultobj;
36834 fail:
36835 return NULL;
36836 }
36837
36838
36839 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36840 PyObject *resultobj = 0;
36841 wxWindow *arg1 = (wxWindow *) 0 ;
36842 wxValidator *result = 0 ;
36843 void *argp1 = 0 ;
36844 int res1 = 0 ;
36845 PyObject *swig_obj[1] ;
36846
36847 if (!args) SWIG_fail;
36848 swig_obj[0] = args;
36849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36850 if (!SWIG_IsOK(res1)) {
36851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36852 }
36853 arg1 = reinterpret_cast< wxWindow * >(argp1);
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = (wxValidator *)(arg1)->GetValidator();
36857 wxPyEndAllowThreads(__tstate);
36858 if (PyErr_Occurred()) SWIG_fail;
36859 }
36860 {
36861 resultobj = wxPyMake_wxObject(result, (bool)0);
36862 }
36863 return resultobj;
36864 fail:
36865 return NULL;
36866 }
36867
36868
36869 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36870 PyObject *resultobj = 0;
36871 wxWindow *arg1 = (wxWindow *) 0 ;
36872 bool result;
36873 void *argp1 = 0 ;
36874 int res1 = 0 ;
36875 PyObject *swig_obj[1] ;
36876
36877 if (!args) SWIG_fail;
36878 swig_obj[0] = args;
36879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36880 if (!SWIG_IsOK(res1)) {
36881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36882 }
36883 arg1 = reinterpret_cast< wxWindow * >(argp1);
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (bool)(arg1)->Validate();
36887 wxPyEndAllowThreads(__tstate);
36888 if (PyErr_Occurred()) SWIG_fail;
36889 }
36890 {
36891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36892 }
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36900 PyObject *resultobj = 0;
36901 wxWindow *arg1 = (wxWindow *) 0 ;
36902 bool result;
36903 void *argp1 = 0 ;
36904 int res1 = 0 ;
36905 PyObject *swig_obj[1] ;
36906
36907 if (!args) SWIG_fail;
36908 swig_obj[0] = args;
36909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 result = (bool)(arg1)->TransferDataToWindow();
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 {
36921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36922 }
36923 return resultobj;
36924 fail:
36925 return NULL;
36926 }
36927
36928
36929 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36930 PyObject *resultobj = 0;
36931 wxWindow *arg1 = (wxWindow *) 0 ;
36932 bool result;
36933 void *argp1 = 0 ;
36934 int res1 = 0 ;
36935 PyObject *swig_obj[1] ;
36936
36937 if (!args) SWIG_fail;
36938 swig_obj[0] = args;
36939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36940 if (!SWIG_IsOK(res1)) {
36941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36942 }
36943 arg1 = reinterpret_cast< wxWindow * >(argp1);
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 result = (bool)(arg1)->TransferDataFromWindow();
36947 wxPyEndAllowThreads(__tstate);
36948 if (PyErr_Occurred()) SWIG_fail;
36949 }
36950 {
36951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36952 }
36953 return resultobj;
36954 fail:
36955 return NULL;
36956 }
36957
36958
36959 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36960 PyObject *resultobj = 0;
36961 wxWindow *arg1 = (wxWindow *) 0 ;
36962 void *argp1 = 0 ;
36963 int res1 = 0 ;
36964 PyObject *swig_obj[1] ;
36965
36966 if (!args) SWIG_fail;
36967 swig_obj[0] = args;
36968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36969 if (!SWIG_IsOK(res1)) {
36970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36971 }
36972 arg1 = reinterpret_cast< wxWindow * >(argp1);
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 (arg1)->InitDialog();
36976 wxPyEndAllowThreads(__tstate);
36977 if (PyErr_Occurred()) SWIG_fail;
36978 }
36979 resultobj = SWIG_Py_Void();
36980 return resultobj;
36981 fail:
36982 return NULL;
36983 }
36984
36985
36986 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36987 PyObject *resultobj = 0;
36988 wxWindow *arg1 = (wxWindow *) 0 ;
36989 wxAcceleratorTable *arg2 = 0 ;
36990 void *argp1 = 0 ;
36991 int res1 = 0 ;
36992 void *argp2 = 0 ;
36993 int res2 = 0 ;
36994 PyObject * obj0 = 0 ;
36995 PyObject * obj1 = 0 ;
36996 char * kwnames[] = {
36997 (char *) "self",(char *) "accel", NULL
36998 };
36999
37000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37002 if (!SWIG_IsOK(res1)) {
37003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37004 }
37005 arg1 = reinterpret_cast< wxWindow * >(argp1);
37006 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37007 if (!SWIG_IsOK(res2)) {
37008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37009 }
37010 if (!argp2) {
37011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37012 }
37013 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 resultobj = SWIG_Py_Void();
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37028 PyObject *resultobj = 0;
37029 wxWindow *arg1 = (wxWindow *) 0 ;
37030 wxAcceleratorTable *result = 0 ;
37031 void *argp1 = 0 ;
37032 int res1 = 0 ;
37033 PyObject *swig_obj[1] ;
37034
37035 if (!args) SWIG_fail;
37036 swig_obj[0] = args;
37037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37038 if (!SWIG_IsOK(res1)) {
37039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37040 }
37041 arg1 = reinterpret_cast< wxWindow * >(argp1);
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37045 wxPyEndAllowThreads(__tstate);
37046 if (PyErr_Occurred()) SWIG_fail;
37047 }
37048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37049 return resultobj;
37050 fail:
37051 return NULL;
37052 }
37053
37054
37055 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37056 PyObject *resultobj = 0;
37057 wxWindow *arg1 = (wxWindow *) 0 ;
37058 int arg2 ;
37059 int arg3 ;
37060 int arg4 ;
37061 bool result;
37062 void *argp1 = 0 ;
37063 int res1 = 0 ;
37064 int val2 ;
37065 int ecode2 = 0 ;
37066 int val3 ;
37067 int ecode3 = 0 ;
37068 int val4 ;
37069 int ecode4 = 0 ;
37070 PyObject * obj0 = 0 ;
37071 PyObject * obj1 = 0 ;
37072 PyObject * obj2 = 0 ;
37073 PyObject * obj3 = 0 ;
37074 char * kwnames[] = {
37075 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37076 };
37077
37078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37080 if (!SWIG_IsOK(res1)) {
37081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37082 }
37083 arg1 = reinterpret_cast< wxWindow * >(argp1);
37084 ecode2 = SWIG_AsVal_int(obj1, &val2);
37085 if (!SWIG_IsOK(ecode2)) {
37086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37087 }
37088 arg2 = static_cast< int >(val2);
37089 ecode3 = SWIG_AsVal_int(obj2, &val3);
37090 if (!SWIG_IsOK(ecode3)) {
37091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37092 }
37093 arg3 = static_cast< int >(val3);
37094 ecode4 = SWIG_AsVal_int(obj3, &val4);
37095 if (!SWIG_IsOK(ecode4)) {
37096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37097 }
37098 arg4 = static_cast< int >(val4);
37099 {
37100 PyThreadState* __tstate = wxPyBeginAllowThreads();
37101 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37102 wxPyEndAllowThreads(__tstate);
37103 if (PyErr_Occurred()) SWIG_fail;
37104 }
37105 {
37106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37107 }
37108 return resultobj;
37109 fail:
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj = 0;
37116 wxWindow *arg1 = (wxWindow *) 0 ;
37117 int arg2 ;
37118 bool result;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 int val2 ;
37122 int ecode2 = 0 ;
37123 PyObject * obj0 = 0 ;
37124 PyObject * obj1 = 0 ;
37125 char * kwnames[] = {
37126 (char *) "self",(char *) "hotkeyId", NULL
37127 };
37128
37129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37131 if (!SWIG_IsOK(res1)) {
37132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37133 }
37134 arg1 = reinterpret_cast< wxWindow * >(argp1);
37135 ecode2 = SWIG_AsVal_int(obj1, &val2);
37136 if (!SWIG_IsOK(ecode2)) {
37137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37138 }
37139 arg2 = static_cast< int >(val2);
37140 {
37141 PyThreadState* __tstate = wxPyBeginAllowThreads();
37142 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37143 wxPyEndAllowThreads(__tstate);
37144 if (PyErr_Occurred()) SWIG_fail;
37145 }
37146 {
37147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37148 }
37149 return resultobj;
37150 fail:
37151 return NULL;
37152 }
37153
37154
37155 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37156 PyObject *resultobj = 0;
37157 wxWindow *arg1 = (wxWindow *) 0 ;
37158 wxPoint *arg2 = 0 ;
37159 wxPoint result;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 wxPoint temp2 ;
37163 PyObject * obj0 = 0 ;
37164 PyObject * obj1 = 0 ;
37165 char * kwnames[] = {
37166 (char *) "self",(char *) "pt", NULL
37167 };
37168
37169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37171 if (!SWIG_IsOK(res1)) {
37172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37173 }
37174 arg1 = reinterpret_cast< wxWindow * >(argp1);
37175 {
37176 arg2 = &temp2;
37177 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37178 }
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37186 return resultobj;
37187 fail:
37188 return NULL;
37189 }
37190
37191
37192 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37193 PyObject *resultobj = 0;
37194 wxWindow *arg1 = (wxWindow *) 0 ;
37195 wxSize *arg2 = 0 ;
37196 wxSize result;
37197 void *argp1 = 0 ;
37198 int res1 = 0 ;
37199 wxSize temp2 ;
37200 PyObject * obj0 = 0 ;
37201 PyObject * obj1 = 0 ;
37202 char * kwnames[] = {
37203 (char *) "self",(char *) "sz", NULL
37204 };
37205
37206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37208 if (!SWIG_IsOK(res1)) {
37209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37210 }
37211 arg1 = reinterpret_cast< wxWindow * >(argp1);
37212 {
37213 arg2 = &temp2;
37214 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37215 }
37216 {
37217 PyThreadState* __tstate = wxPyBeginAllowThreads();
37218 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37223 return resultobj;
37224 fail:
37225 return NULL;
37226 }
37227
37228
37229 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37230 PyObject *resultobj = 0;
37231 wxWindow *arg1 = (wxWindow *) 0 ;
37232 wxPoint *arg2 = 0 ;
37233 wxPoint result;
37234 void *argp1 = 0 ;
37235 int res1 = 0 ;
37236 wxPoint temp2 ;
37237 PyObject * obj0 = 0 ;
37238 PyObject * obj1 = 0 ;
37239 char * kwnames[] = {
37240 (char *) "self",(char *) "pt", NULL
37241 };
37242
37243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37245 if (!SWIG_IsOK(res1)) {
37246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37247 }
37248 arg1 = reinterpret_cast< wxWindow * >(argp1);
37249 {
37250 arg2 = &temp2;
37251 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37252 }
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37267 PyObject *resultobj = 0;
37268 wxWindow *arg1 = (wxWindow *) 0 ;
37269 wxSize *arg2 = 0 ;
37270 wxSize result;
37271 void *argp1 = 0 ;
37272 int res1 = 0 ;
37273 wxSize temp2 ;
37274 PyObject * obj0 = 0 ;
37275 PyObject * obj1 = 0 ;
37276 char * kwnames[] = {
37277 (char *) "self",(char *) "sz", NULL
37278 };
37279
37280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37282 if (!SWIG_IsOK(res1)) {
37283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37284 }
37285 arg1 = reinterpret_cast< wxWindow * >(argp1);
37286 {
37287 arg2 = &temp2;
37288 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37289 }
37290 {
37291 PyThreadState* __tstate = wxPyBeginAllowThreads();
37292 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37293 wxPyEndAllowThreads(__tstate);
37294 if (PyErr_Occurred()) SWIG_fail;
37295 }
37296 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37297 return resultobj;
37298 fail:
37299 return NULL;
37300 }
37301
37302
37303 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37304 PyObject *resultobj = 0;
37305 wxWindow *arg1 = (wxWindow *) 0 ;
37306 wxPoint *arg2 = 0 ;
37307 wxPoint result;
37308 void *argp1 = 0 ;
37309 int res1 = 0 ;
37310 wxPoint temp2 ;
37311 PyObject * obj0 = 0 ;
37312 PyObject * obj1 = 0 ;
37313 char * kwnames[] = {
37314 (char *) "self",(char *) "pt", NULL
37315 };
37316
37317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37319 if (!SWIG_IsOK(res1)) {
37320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37321 }
37322 arg1 = reinterpret_cast< wxWindow * >(argp1);
37323 {
37324 arg2 = &temp2;
37325 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37326 }
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 wxSize *arg2 = 0 ;
37344 wxSize result;
37345 void *argp1 = 0 ;
37346 int res1 = 0 ;
37347 wxSize temp2 ;
37348 PyObject * obj0 = 0 ;
37349 PyObject * obj1 = 0 ;
37350 char * kwnames[] = {
37351 (char *) "self",(char *) "sz", NULL
37352 };
37353
37354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37356 if (!SWIG_IsOK(res1)) {
37357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37358 }
37359 arg1 = reinterpret_cast< wxWindow * >(argp1);
37360 {
37361 arg2 = &temp2;
37362 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37363 }
37364 {
37365 PyThreadState* __tstate = wxPyBeginAllowThreads();
37366 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37367 wxPyEndAllowThreads(__tstate);
37368 if (PyErr_Occurred()) SWIG_fail;
37369 }
37370 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37371 return resultobj;
37372 fail:
37373 return NULL;
37374 }
37375
37376
37377 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37378 PyObject *resultobj = 0;
37379 wxWindow *arg1 = (wxWindow *) 0 ;
37380 int arg2 ;
37381 int arg3 ;
37382 void *argp1 = 0 ;
37383 int res1 = 0 ;
37384 int val2 ;
37385 int ecode2 = 0 ;
37386 int val3 ;
37387 int ecode3 = 0 ;
37388 PyObject * obj0 = 0 ;
37389 PyObject * obj1 = 0 ;
37390 PyObject * obj2 = 0 ;
37391 char * kwnames[] = {
37392 (char *) "self",(char *) "x",(char *) "y", NULL
37393 };
37394
37395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37397 if (!SWIG_IsOK(res1)) {
37398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37399 }
37400 arg1 = reinterpret_cast< wxWindow * >(argp1);
37401 ecode2 = SWIG_AsVal_int(obj1, &val2);
37402 if (!SWIG_IsOK(ecode2)) {
37403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37404 }
37405 arg2 = static_cast< int >(val2);
37406 ecode3 = SWIG_AsVal_int(obj2, &val3);
37407 if (!SWIG_IsOK(ecode3)) {
37408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37409 }
37410 arg3 = static_cast< int >(val3);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 (arg1)->WarpPointer(arg2,arg3);
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = SWIG_Py_Void();
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *resultobj = 0;
37426 wxWindow *arg1 = (wxWindow *) 0 ;
37427 void *argp1 = 0 ;
37428 int res1 = 0 ;
37429 PyObject *swig_obj[1] ;
37430
37431 if (!args) SWIG_fail;
37432 swig_obj[0] = args;
37433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37434 if (!SWIG_IsOK(res1)) {
37435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37436 }
37437 arg1 = reinterpret_cast< wxWindow * >(argp1);
37438 {
37439 PyThreadState* __tstate = wxPyBeginAllowThreads();
37440 (arg1)->CaptureMouse();
37441 wxPyEndAllowThreads(__tstate);
37442 if (PyErr_Occurred()) SWIG_fail;
37443 }
37444 resultobj = SWIG_Py_Void();
37445 return resultobj;
37446 fail:
37447 return NULL;
37448 }
37449
37450
37451 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37452 PyObject *resultobj = 0;
37453 wxWindow *arg1 = (wxWindow *) 0 ;
37454 void *argp1 = 0 ;
37455 int res1 = 0 ;
37456 PyObject *swig_obj[1] ;
37457
37458 if (!args) SWIG_fail;
37459 swig_obj[0] = args;
37460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37461 if (!SWIG_IsOK(res1)) {
37462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37463 }
37464 arg1 = reinterpret_cast< wxWindow * >(argp1);
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 (arg1)->ReleaseMouse();
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 resultobj = SWIG_Py_Void();
37472 return resultobj;
37473 fail:
37474 return NULL;
37475 }
37476
37477
37478 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37479 PyObject *resultobj = 0;
37480 wxWindow *result = 0 ;
37481
37482 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37483 {
37484 if (!wxPyCheckForApp()) SWIG_fail;
37485 PyThreadState* __tstate = wxPyBeginAllowThreads();
37486 result = (wxWindow *)wxWindow::GetCapture();
37487 wxPyEndAllowThreads(__tstate);
37488 if (PyErr_Occurred()) SWIG_fail;
37489 }
37490 {
37491 resultobj = wxPyMake_wxObject(result, 0);
37492 }
37493 return resultobj;
37494 fail:
37495 return NULL;
37496 }
37497
37498
37499 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37500 PyObject *resultobj = 0;
37501 wxWindow *arg1 = (wxWindow *) 0 ;
37502 bool result;
37503 void *argp1 = 0 ;
37504 int res1 = 0 ;
37505 PyObject *swig_obj[1] ;
37506
37507 if (!args) SWIG_fail;
37508 swig_obj[0] = args;
37509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37512 }
37513 arg1 = reinterpret_cast< wxWindow * >(argp1);
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 result = (bool)((wxWindow const *)arg1)->HasCapture();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 {
37521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37522 }
37523 return resultobj;
37524 fail:
37525 return NULL;
37526 }
37527
37528
37529 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37530 PyObject *resultobj = 0;
37531 wxWindow *arg1 = (wxWindow *) 0 ;
37532 bool arg2 = (bool) true ;
37533 wxRect *arg3 = (wxRect *) NULL ;
37534 void *argp1 = 0 ;
37535 int res1 = 0 ;
37536 bool val2 ;
37537 int ecode2 = 0 ;
37538 void *argp3 = 0 ;
37539 int res3 = 0 ;
37540 PyObject * obj0 = 0 ;
37541 PyObject * obj1 = 0 ;
37542 PyObject * obj2 = 0 ;
37543 char * kwnames[] = {
37544 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37545 };
37546
37547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37549 if (!SWIG_IsOK(res1)) {
37550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37551 }
37552 arg1 = reinterpret_cast< wxWindow * >(argp1);
37553 if (obj1) {
37554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37555 if (!SWIG_IsOK(ecode2)) {
37556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37557 }
37558 arg2 = static_cast< bool >(val2);
37559 }
37560 if (obj2) {
37561 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37562 if (!SWIG_IsOK(res3)) {
37563 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37564 }
37565 arg3 = reinterpret_cast< wxRect * >(argp3);
37566 }
37567 {
37568 PyThreadState* __tstate = wxPyBeginAllowThreads();
37569 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37570 wxPyEndAllowThreads(__tstate);
37571 if (PyErr_Occurred()) SWIG_fail;
37572 }
37573 resultobj = SWIG_Py_Void();
37574 return resultobj;
37575 fail:
37576 return NULL;
37577 }
37578
37579
37580 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37581 PyObject *resultobj = 0;
37582 wxWindow *arg1 = (wxWindow *) 0 ;
37583 wxRect *arg2 = 0 ;
37584 bool arg3 = (bool) true ;
37585 void *argp1 = 0 ;
37586 int res1 = 0 ;
37587 wxRect temp2 ;
37588 bool val3 ;
37589 int ecode3 = 0 ;
37590 PyObject * obj0 = 0 ;
37591 PyObject * obj1 = 0 ;
37592 PyObject * obj2 = 0 ;
37593 char * kwnames[] = {
37594 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37595 };
37596
37597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37599 if (!SWIG_IsOK(res1)) {
37600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37601 }
37602 arg1 = reinterpret_cast< wxWindow * >(argp1);
37603 {
37604 arg2 = &temp2;
37605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37606 }
37607 if (obj2) {
37608 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37609 if (!SWIG_IsOK(ecode3)) {
37610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37611 }
37612 arg3 = static_cast< bool >(val3);
37613 }
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 resultobj = SWIG_Py_Void();
37621 return resultobj;
37622 fail:
37623 return NULL;
37624 }
37625
37626
37627 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37628 PyObject *resultobj = 0;
37629 wxWindow *arg1 = (wxWindow *) 0 ;
37630 void *argp1 = 0 ;
37631 int res1 = 0 ;
37632 PyObject *swig_obj[1] ;
37633
37634 if (!args) SWIG_fail;
37635 swig_obj[0] = args;
37636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37637 if (!SWIG_IsOK(res1)) {
37638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37639 }
37640 arg1 = reinterpret_cast< wxWindow * >(argp1);
37641 {
37642 PyThreadState* __tstate = wxPyBeginAllowThreads();
37643 (arg1)->Update();
37644 wxPyEndAllowThreads(__tstate);
37645 if (PyErr_Occurred()) SWIG_fail;
37646 }
37647 resultobj = SWIG_Py_Void();
37648 return resultobj;
37649 fail:
37650 return NULL;
37651 }
37652
37653
37654 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37655 PyObject *resultobj = 0;
37656 wxWindow *arg1 = (wxWindow *) 0 ;
37657 void *argp1 = 0 ;
37658 int res1 = 0 ;
37659 PyObject *swig_obj[1] ;
37660
37661 if (!args) SWIG_fail;
37662 swig_obj[0] = args;
37663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37664 if (!SWIG_IsOK(res1)) {
37665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37666 }
37667 arg1 = reinterpret_cast< wxWindow * >(argp1);
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->ClearBackground();
37671 wxPyEndAllowThreads(__tstate);
37672 if (PyErr_Occurred()) SWIG_fail;
37673 }
37674 resultobj = SWIG_Py_Void();
37675 return resultobj;
37676 fail:
37677 return NULL;
37678 }
37679
37680
37681 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37682 PyObject *resultobj = 0;
37683 wxWindow *arg1 = (wxWindow *) 0 ;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 PyObject *swig_obj[1] ;
37687
37688 if (!args) SWIG_fail;
37689 swig_obj[0] = args;
37690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37691 if (!SWIG_IsOK(res1)) {
37692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37693 }
37694 arg1 = reinterpret_cast< wxWindow * >(argp1);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 (arg1)->Freeze();
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 resultobj = SWIG_Py_Void();
37702 return resultobj;
37703 fail:
37704 return NULL;
37705 }
37706
37707
37708 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37709 PyObject *resultobj = 0;
37710 wxWindow *arg1 = (wxWindow *) 0 ;
37711 bool result;
37712 void *argp1 = 0 ;
37713 int res1 = 0 ;
37714 PyObject *swig_obj[1] ;
37715
37716 if (!args) SWIG_fail;
37717 swig_obj[0] = args;
37718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37719 if (!SWIG_IsOK(res1)) {
37720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37721 }
37722 arg1 = reinterpret_cast< wxWindow * >(argp1);
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 {
37730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37731 }
37732 return resultobj;
37733 fail:
37734 return NULL;
37735 }
37736
37737
37738 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37739 PyObject *resultobj = 0;
37740 wxWindow *arg1 = (wxWindow *) 0 ;
37741 void *argp1 = 0 ;
37742 int res1 = 0 ;
37743 PyObject *swig_obj[1] ;
37744
37745 if (!args) SWIG_fail;
37746 swig_obj[0] = args;
37747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37748 if (!SWIG_IsOK(res1)) {
37749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37750 }
37751 arg1 = reinterpret_cast< wxWindow * >(argp1);
37752 {
37753 PyThreadState* __tstate = wxPyBeginAllowThreads();
37754 (arg1)->Thaw();
37755 wxPyEndAllowThreads(__tstate);
37756 if (PyErr_Occurred()) SWIG_fail;
37757 }
37758 resultobj = SWIG_Py_Void();
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj = 0;
37767 wxWindow *arg1 = (wxWindow *) 0 ;
37768 wxDC *arg2 = 0 ;
37769 void *argp1 = 0 ;
37770 int res1 = 0 ;
37771 void *argp2 = 0 ;
37772 int res2 = 0 ;
37773 PyObject * obj0 = 0 ;
37774 PyObject * obj1 = 0 ;
37775 char * kwnames[] = {
37776 (char *) "self",(char *) "dc", NULL
37777 };
37778
37779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37781 if (!SWIG_IsOK(res1)) {
37782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37783 }
37784 arg1 = reinterpret_cast< wxWindow * >(argp1);
37785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37786 if (!SWIG_IsOK(res2)) {
37787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37788 }
37789 if (!argp2) {
37790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37791 }
37792 arg2 = reinterpret_cast< wxDC * >(argp2);
37793 {
37794 PyThreadState* __tstate = wxPyBeginAllowThreads();
37795 (arg1)->PrepareDC(*arg2);
37796 wxPyEndAllowThreads(__tstate);
37797 if (PyErr_Occurred()) SWIG_fail;
37798 }
37799 resultobj = SWIG_Py_Void();
37800 return resultobj;
37801 fail:
37802 return NULL;
37803 }
37804
37805
37806 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37807 PyObject *resultobj = 0;
37808 wxWindow *arg1 = (wxWindow *) 0 ;
37809 bool result;
37810 void *argp1 = 0 ;
37811 int res1 = 0 ;
37812 PyObject *swig_obj[1] ;
37813
37814 if (!args) SWIG_fail;
37815 swig_obj[0] = args;
37816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37817 if (!SWIG_IsOK(res1)) {
37818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37819 }
37820 arg1 = reinterpret_cast< wxWindow * >(argp1);
37821 {
37822 PyThreadState* __tstate = wxPyBeginAllowThreads();
37823 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37824 wxPyEndAllowThreads(__tstate);
37825 if (PyErr_Occurred()) SWIG_fail;
37826 }
37827 {
37828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37829 }
37830 return resultobj;
37831 fail:
37832 return NULL;
37833 }
37834
37835
37836 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37837 PyObject *resultobj = 0;
37838 wxWindow *arg1 = (wxWindow *) 0 ;
37839 wxRegion *result = 0 ;
37840 void *argp1 = 0 ;
37841 int res1 = 0 ;
37842 PyObject *swig_obj[1] ;
37843
37844 if (!args) SWIG_fail;
37845 swig_obj[0] = args;
37846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37847 if (!SWIG_IsOK(res1)) {
37848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37849 }
37850 arg1 = reinterpret_cast< wxWindow * >(argp1);
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 {
37854 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37855 result = (wxRegion *) &_result_ref;
37856 }
37857 wxPyEndAllowThreads(__tstate);
37858 if (PyErr_Occurred()) SWIG_fail;
37859 }
37860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37861 return resultobj;
37862 fail:
37863 return NULL;
37864 }
37865
37866
37867 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37868 PyObject *resultobj = 0;
37869 wxWindow *arg1 = (wxWindow *) 0 ;
37870 wxRect result;
37871 void *argp1 = 0 ;
37872 int res1 = 0 ;
37873 PyObject *swig_obj[1] ;
37874
37875 if (!args) SWIG_fail;
37876 swig_obj[0] = args;
37877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37878 if (!SWIG_IsOK(res1)) {
37879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37880 }
37881 arg1 = reinterpret_cast< wxWindow * >(argp1);
37882 {
37883 PyThreadState* __tstate = wxPyBeginAllowThreads();
37884 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37885 wxPyEndAllowThreads(__tstate);
37886 if (PyErr_Occurred()) SWIG_fail;
37887 }
37888 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37889 return resultobj;
37890 fail:
37891 return NULL;
37892 }
37893
37894
37895 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37896 PyObject *resultobj = 0;
37897 wxWindow *arg1 = (wxWindow *) 0 ;
37898 int arg2 ;
37899 int arg3 ;
37900 int arg4 = (int) 1 ;
37901 int arg5 = (int) 1 ;
37902 bool result;
37903 void *argp1 = 0 ;
37904 int res1 = 0 ;
37905 int val2 ;
37906 int ecode2 = 0 ;
37907 int val3 ;
37908 int ecode3 = 0 ;
37909 int val4 ;
37910 int ecode4 = 0 ;
37911 int val5 ;
37912 int ecode5 = 0 ;
37913 PyObject * obj0 = 0 ;
37914 PyObject * obj1 = 0 ;
37915 PyObject * obj2 = 0 ;
37916 PyObject * obj3 = 0 ;
37917 PyObject * obj4 = 0 ;
37918 char * kwnames[] = {
37919 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37920 };
37921
37922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37924 if (!SWIG_IsOK(res1)) {
37925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37926 }
37927 arg1 = reinterpret_cast< wxWindow * >(argp1);
37928 ecode2 = SWIG_AsVal_int(obj1, &val2);
37929 if (!SWIG_IsOK(ecode2)) {
37930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37931 }
37932 arg2 = static_cast< int >(val2);
37933 ecode3 = SWIG_AsVal_int(obj2, &val3);
37934 if (!SWIG_IsOK(ecode3)) {
37935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37936 }
37937 arg3 = static_cast< int >(val3);
37938 if (obj3) {
37939 ecode4 = SWIG_AsVal_int(obj3, &val4);
37940 if (!SWIG_IsOK(ecode4)) {
37941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37942 }
37943 arg4 = static_cast< int >(val4);
37944 }
37945 if (obj4) {
37946 ecode5 = SWIG_AsVal_int(obj4, &val5);
37947 if (!SWIG_IsOK(ecode5)) {
37948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37949 }
37950 arg5 = static_cast< int >(val5);
37951 }
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 {
37959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37960 }
37961 return resultobj;
37962 fail:
37963 return NULL;
37964 }
37965
37966
37967 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37968 PyObject *resultobj = 0;
37969 wxWindow *arg1 = (wxWindow *) 0 ;
37970 wxPoint *arg2 = 0 ;
37971 bool result;
37972 void *argp1 = 0 ;
37973 int res1 = 0 ;
37974 wxPoint temp2 ;
37975 PyObject * obj0 = 0 ;
37976 PyObject * obj1 = 0 ;
37977 char * kwnames[] = {
37978 (char *) "self",(char *) "pt", NULL
37979 };
37980
37981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37983 if (!SWIG_IsOK(res1)) {
37984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37985 }
37986 arg1 = reinterpret_cast< wxWindow * >(argp1);
37987 {
37988 arg2 = &temp2;
37989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37990 }
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 {
37998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37999 }
38000 return resultobj;
38001 fail:
38002 return NULL;
38003 }
38004
38005
38006 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38007 PyObject *resultobj = 0;
38008 wxWindow *arg1 = (wxWindow *) 0 ;
38009 wxRect *arg2 = 0 ;
38010 bool result;
38011 void *argp1 = 0 ;
38012 int res1 = 0 ;
38013 wxRect temp2 ;
38014 PyObject * obj0 = 0 ;
38015 PyObject * obj1 = 0 ;
38016 char * kwnames[] = {
38017 (char *) "self",(char *) "rect", NULL
38018 };
38019
38020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38022 if (!SWIG_IsOK(res1)) {
38023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38024 }
38025 arg1 = reinterpret_cast< wxWindow * >(argp1);
38026 {
38027 arg2 = &temp2;
38028 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38029 }
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 {
38037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38046 PyObject *resultobj = 0;
38047 wxWindow *arg1 = (wxWindow *) 0 ;
38048 SwigValueWrapper<wxVisualAttributes > result;
38049 void *argp1 = 0 ;
38050 int res1 = 0 ;
38051 PyObject *swig_obj[1] ;
38052
38053 if (!args) SWIG_fail;
38054 swig_obj[0] = args;
38055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38056 if (!SWIG_IsOK(res1)) {
38057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38058 }
38059 arg1 = reinterpret_cast< wxWindow * >(argp1);
38060 {
38061 PyThreadState* __tstate = wxPyBeginAllowThreads();
38062 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38063 wxPyEndAllowThreads(__tstate);
38064 if (PyErr_Occurred()) SWIG_fail;
38065 }
38066 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38067 return resultobj;
38068 fail:
38069 return NULL;
38070 }
38071
38072
38073 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38074 PyObject *resultobj = 0;
38075 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38076 SwigValueWrapper<wxVisualAttributes > result;
38077 int val1 ;
38078 int ecode1 = 0 ;
38079 PyObject * obj0 = 0 ;
38080 char * kwnames[] = {
38081 (char *) "variant", NULL
38082 };
38083
38084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38085 if (obj0) {
38086 ecode1 = SWIG_AsVal_int(obj0, &val1);
38087 if (!SWIG_IsOK(ecode1)) {
38088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38089 }
38090 arg1 = static_cast< wxWindowVariant >(val1);
38091 }
38092 {
38093 if (!wxPyCheckForApp()) SWIG_fail;
38094 PyThreadState* __tstate = wxPyBeginAllowThreads();
38095 result = wxWindow::GetClassDefaultAttributes(arg1);
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38100 return resultobj;
38101 fail:
38102 return NULL;
38103 }
38104
38105
38106 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38107 PyObject *resultobj = 0;
38108 wxWindow *arg1 = (wxWindow *) 0 ;
38109 wxColour *arg2 = 0 ;
38110 bool result;
38111 void *argp1 = 0 ;
38112 int res1 = 0 ;
38113 wxColour temp2 ;
38114 PyObject * obj0 = 0 ;
38115 PyObject * obj1 = 0 ;
38116 char * kwnames[] = {
38117 (char *) "self",(char *) "colour", NULL
38118 };
38119
38120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38122 if (!SWIG_IsOK(res1)) {
38123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38124 }
38125 arg1 = reinterpret_cast< wxWindow * >(argp1);
38126 {
38127 arg2 = &temp2;
38128 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38129 }
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38133 wxPyEndAllowThreads(__tstate);
38134 if (PyErr_Occurred()) SWIG_fail;
38135 }
38136 {
38137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38138 }
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindow *arg1 = (wxWindow *) 0 ;
38148 wxColour *arg2 = 0 ;
38149 void *argp1 = 0 ;
38150 int res1 = 0 ;
38151 wxColour temp2 ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 char * kwnames[] = {
38155 (char *) "self",(char *) "colour", NULL
38156 };
38157
38158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38162 }
38163 arg1 = reinterpret_cast< wxWindow * >(argp1);
38164 {
38165 arg2 = &temp2;
38166 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38167 }
38168 {
38169 PyThreadState* __tstate = wxPyBeginAllowThreads();
38170 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38171 wxPyEndAllowThreads(__tstate);
38172 if (PyErr_Occurred()) SWIG_fail;
38173 }
38174 resultobj = SWIG_Py_Void();
38175 return resultobj;
38176 fail:
38177 return NULL;
38178 }
38179
38180
38181 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38182 PyObject *resultobj = 0;
38183 wxWindow *arg1 = (wxWindow *) 0 ;
38184 wxColour *arg2 = 0 ;
38185 bool result;
38186 void *argp1 = 0 ;
38187 int res1 = 0 ;
38188 wxColour temp2 ;
38189 PyObject * obj0 = 0 ;
38190 PyObject * obj1 = 0 ;
38191 char * kwnames[] = {
38192 (char *) "self",(char *) "colour", NULL
38193 };
38194
38195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38197 if (!SWIG_IsOK(res1)) {
38198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38199 }
38200 arg1 = reinterpret_cast< wxWindow * >(argp1);
38201 {
38202 arg2 = &temp2;
38203 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38204 }
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 {
38212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38213 }
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38221 PyObject *resultobj = 0;
38222 wxWindow *arg1 = (wxWindow *) 0 ;
38223 wxColour *arg2 = 0 ;
38224 void *argp1 = 0 ;
38225 int res1 = 0 ;
38226 wxColour temp2 ;
38227 PyObject * obj0 = 0 ;
38228 PyObject * obj1 = 0 ;
38229 char * kwnames[] = {
38230 (char *) "self",(char *) "colour", NULL
38231 };
38232
38233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38235 if (!SWIG_IsOK(res1)) {
38236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38237 }
38238 arg1 = reinterpret_cast< wxWindow * >(argp1);
38239 {
38240 arg2 = &temp2;
38241 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38242 }
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 resultobj = SWIG_Py_Void();
38250 return resultobj;
38251 fail:
38252 return NULL;
38253 }
38254
38255
38256 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38257 PyObject *resultobj = 0;
38258 wxWindow *arg1 = (wxWindow *) 0 ;
38259 wxColour result;
38260 void *argp1 = 0 ;
38261 int res1 = 0 ;
38262 PyObject *swig_obj[1] ;
38263
38264 if (!args) SWIG_fail;
38265 swig_obj[0] = args;
38266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38267 if (!SWIG_IsOK(res1)) {
38268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38269 }
38270 arg1 = reinterpret_cast< wxWindow * >(argp1);
38271 {
38272 PyThreadState* __tstate = wxPyBeginAllowThreads();
38273 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38274 wxPyEndAllowThreads(__tstate);
38275 if (PyErr_Occurred()) SWIG_fail;
38276 }
38277 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38285 PyObject *resultobj = 0;
38286 wxWindow *arg1 = (wxWindow *) 0 ;
38287 wxColour result;
38288 void *argp1 = 0 ;
38289 int res1 = 0 ;
38290 PyObject *swig_obj[1] ;
38291
38292 if (!args) SWIG_fail;
38293 swig_obj[0] = args;
38294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38295 if (!SWIG_IsOK(res1)) {
38296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38297 }
38298 arg1 = reinterpret_cast< wxWindow * >(argp1);
38299 {
38300 PyThreadState* __tstate = wxPyBeginAllowThreads();
38301 result = ((wxWindow const *)arg1)->GetForegroundColour();
38302 wxPyEndAllowThreads(__tstate);
38303 if (PyErr_Occurred()) SWIG_fail;
38304 }
38305 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38306 return resultobj;
38307 fail:
38308 return NULL;
38309 }
38310
38311
38312 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38313 PyObject *resultobj = 0;
38314 wxWindow *arg1 = (wxWindow *) 0 ;
38315 bool result;
38316 void *argp1 = 0 ;
38317 int res1 = 0 ;
38318 PyObject *swig_obj[1] ;
38319
38320 if (!args) SWIG_fail;
38321 swig_obj[0] = args;
38322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38323 if (!SWIG_IsOK(res1)) {
38324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38325 }
38326 arg1 = reinterpret_cast< wxWindow * >(argp1);
38327 {
38328 PyThreadState* __tstate = wxPyBeginAllowThreads();
38329 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38330 wxPyEndAllowThreads(__tstate);
38331 if (PyErr_Occurred()) SWIG_fail;
38332 }
38333 {
38334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38335 }
38336 return resultobj;
38337 fail:
38338 return NULL;
38339 }
38340
38341
38342 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38343 PyObject *resultobj = 0;
38344 wxWindow *arg1 = (wxWindow *) 0 ;
38345 bool result;
38346 void *argp1 = 0 ;
38347 int res1 = 0 ;
38348 PyObject *swig_obj[1] ;
38349
38350 if (!args) SWIG_fail;
38351 swig_obj[0] = args;
38352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38353 if (!SWIG_IsOK(res1)) {
38354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38355 }
38356 arg1 = reinterpret_cast< wxWindow * >(argp1);
38357 {
38358 PyThreadState* __tstate = wxPyBeginAllowThreads();
38359 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38360 wxPyEndAllowThreads(__tstate);
38361 if (PyErr_Occurred()) SWIG_fail;
38362 }
38363 {
38364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38365 }
38366 return resultobj;
38367 fail:
38368 return NULL;
38369 }
38370
38371
38372 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38373 PyObject *resultobj = 0;
38374 wxWindow *arg1 = (wxWindow *) 0 ;
38375 wxBackgroundStyle arg2 ;
38376 bool result;
38377 void *argp1 = 0 ;
38378 int res1 = 0 ;
38379 int val2 ;
38380 int ecode2 = 0 ;
38381 PyObject * obj0 = 0 ;
38382 PyObject * obj1 = 0 ;
38383 char * kwnames[] = {
38384 (char *) "self",(char *) "style", NULL
38385 };
38386
38387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38389 if (!SWIG_IsOK(res1)) {
38390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38391 }
38392 arg1 = reinterpret_cast< wxWindow * >(argp1);
38393 ecode2 = SWIG_AsVal_int(obj1, &val2);
38394 if (!SWIG_IsOK(ecode2)) {
38395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38396 }
38397 arg2 = static_cast< wxBackgroundStyle >(val2);
38398 {
38399 PyThreadState* __tstate = wxPyBeginAllowThreads();
38400 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38401 wxPyEndAllowThreads(__tstate);
38402 if (PyErr_Occurred()) SWIG_fail;
38403 }
38404 {
38405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38406 }
38407 return resultobj;
38408 fail:
38409 return NULL;
38410 }
38411
38412
38413 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38414 PyObject *resultobj = 0;
38415 wxWindow *arg1 = (wxWindow *) 0 ;
38416 wxBackgroundStyle result;
38417 void *argp1 = 0 ;
38418 int res1 = 0 ;
38419 PyObject *swig_obj[1] ;
38420
38421 if (!args) SWIG_fail;
38422 swig_obj[0] = args;
38423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38424 if (!SWIG_IsOK(res1)) {
38425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38426 }
38427 arg1 = reinterpret_cast< wxWindow * >(argp1);
38428 {
38429 PyThreadState* __tstate = wxPyBeginAllowThreads();
38430 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38431 wxPyEndAllowThreads(__tstate);
38432 if (PyErr_Occurred()) SWIG_fail;
38433 }
38434 resultobj = SWIG_From_int(static_cast< int >(result));
38435 return resultobj;
38436 fail:
38437 return NULL;
38438 }
38439
38440
38441 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38442 PyObject *resultobj = 0;
38443 wxWindow *arg1 = (wxWindow *) 0 ;
38444 bool result;
38445 void *argp1 = 0 ;
38446 int res1 = 0 ;
38447 PyObject *swig_obj[1] ;
38448
38449 if (!args) SWIG_fail;
38450 swig_obj[0] = args;
38451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38452 if (!SWIG_IsOK(res1)) {
38453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38454 }
38455 arg1 = reinterpret_cast< wxWindow * >(argp1);
38456 {
38457 PyThreadState* __tstate = wxPyBeginAllowThreads();
38458 result = (bool)(arg1)->HasTransparentBackground();
38459 wxPyEndAllowThreads(__tstate);
38460 if (PyErr_Occurred()) SWIG_fail;
38461 }
38462 {
38463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38464 }
38465 return resultobj;
38466 fail:
38467 return NULL;
38468 }
38469
38470
38471 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38472 PyObject *resultobj = 0;
38473 wxWindow *arg1 = (wxWindow *) 0 ;
38474 wxCursor *arg2 = 0 ;
38475 bool result;
38476 void *argp1 = 0 ;
38477 int res1 = 0 ;
38478 void *argp2 = 0 ;
38479 int res2 = 0 ;
38480 PyObject * obj0 = 0 ;
38481 PyObject * obj1 = 0 ;
38482 char * kwnames[] = {
38483 (char *) "self",(char *) "cursor", NULL
38484 };
38485
38486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38488 if (!SWIG_IsOK(res1)) {
38489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38490 }
38491 arg1 = reinterpret_cast< wxWindow * >(argp1);
38492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38493 if (!SWIG_IsOK(res2)) {
38494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38495 }
38496 if (!argp2) {
38497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38498 }
38499 arg2 = reinterpret_cast< wxCursor * >(argp2);
38500 {
38501 PyThreadState* __tstate = wxPyBeginAllowThreads();
38502 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38503 wxPyEndAllowThreads(__tstate);
38504 if (PyErr_Occurred()) SWIG_fail;
38505 }
38506 {
38507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38508 }
38509 return resultobj;
38510 fail:
38511 return NULL;
38512 }
38513
38514
38515 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38516 PyObject *resultobj = 0;
38517 wxWindow *arg1 = (wxWindow *) 0 ;
38518 wxCursor result;
38519 void *argp1 = 0 ;
38520 int res1 = 0 ;
38521 PyObject *swig_obj[1] ;
38522
38523 if (!args) SWIG_fail;
38524 swig_obj[0] = args;
38525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38526 if (!SWIG_IsOK(res1)) {
38527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38528 }
38529 arg1 = reinterpret_cast< wxWindow * >(argp1);
38530 {
38531 PyThreadState* __tstate = wxPyBeginAllowThreads();
38532 result = (arg1)->GetCursor();
38533 wxPyEndAllowThreads(__tstate);
38534 if (PyErr_Occurred()) SWIG_fail;
38535 }
38536 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38537 return resultobj;
38538 fail:
38539 return NULL;
38540 }
38541
38542
38543 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38544 PyObject *resultobj = 0;
38545 wxWindow *arg1 = (wxWindow *) 0 ;
38546 wxFont *arg2 = 0 ;
38547 bool result;
38548 void *argp1 = 0 ;
38549 int res1 = 0 ;
38550 void *argp2 = 0 ;
38551 int res2 = 0 ;
38552 PyObject * obj0 = 0 ;
38553 PyObject * obj1 = 0 ;
38554 char * kwnames[] = {
38555 (char *) "self",(char *) "font", NULL
38556 };
38557
38558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38560 if (!SWIG_IsOK(res1)) {
38561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38562 }
38563 arg1 = reinterpret_cast< wxWindow * >(argp1);
38564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38565 if (!SWIG_IsOK(res2)) {
38566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38567 }
38568 if (!argp2) {
38569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38570 }
38571 arg2 = reinterpret_cast< wxFont * >(argp2);
38572 {
38573 PyThreadState* __tstate = wxPyBeginAllowThreads();
38574 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 {
38579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38580 }
38581 return resultobj;
38582 fail:
38583 return NULL;
38584 }
38585
38586
38587 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38588 PyObject *resultobj = 0;
38589 wxWindow *arg1 = (wxWindow *) 0 ;
38590 wxFont *arg2 = 0 ;
38591 void *argp1 = 0 ;
38592 int res1 = 0 ;
38593 void *argp2 = 0 ;
38594 int res2 = 0 ;
38595 PyObject * obj0 = 0 ;
38596 PyObject * obj1 = 0 ;
38597 char * kwnames[] = {
38598 (char *) "self",(char *) "font", NULL
38599 };
38600
38601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38603 if (!SWIG_IsOK(res1)) {
38604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38605 }
38606 arg1 = reinterpret_cast< wxWindow * >(argp1);
38607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38608 if (!SWIG_IsOK(res2)) {
38609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38610 }
38611 if (!argp2) {
38612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38613 }
38614 arg2 = reinterpret_cast< wxFont * >(argp2);
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 (arg1)->SetOwnFont((wxFont const &)*arg2);
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 resultobj = SWIG_Py_Void();
38622 return resultobj;
38623 fail:
38624 return NULL;
38625 }
38626
38627
38628 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38629 PyObject *resultobj = 0;
38630 wxWindow *arg1 = (wxWindow *) 0 ;
38631 wxFont result;
38632 void *argp1 = 0 ;
38633 int res1 = 0 ;
38634 PyObject *swig_obj[1] ;
38635
38636 if (!args) SWIG_fail;
38637 swig_obj[0] = args;
38638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38639 if (!SWIG_IsOK(res1)) {
38640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38641 }
38642 arg1 = reinterpret_cast< wxWindow * >(argp1);
38643 {
38644 PyThreadState* __tstate = wxPyBeginAllowThreads();
38645 result = (arg1)->GetFont();
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38650 return resultobj;
38651 fail:
38652 return NULL;
38653 }
38654
38655
38656 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38657 PyObject *resultobj = 0;
38658 wxWindow *arg1 = (wxWindow *) 0 ;
38659 wxCaret *arg2 = (wxCaret *) 0 ;
38660 void *argp1 = 0 ;
38661 int res1 = 0 ;
38662 int res2 = 0 ;
38663 PyObject * obj0 = 0 ;
38664 PyObject * obj1 = 0 ;
38665 char * kwnames[] = {
38666 (char *) "self",(char *) "caret", NULL
38667 };
38668
38669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38671 if (!SWIG_IsOK(res1)) {
38672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38673 }
38674 arg1 = reinterpret_cast< wxWindow * >(argp1);
38675 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38676 if (!SWIG_IsOK(res2)) {
38677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38678 }
38679 {
38680 PyThreadState* __tstate = wxPyBeginAllowThreads();
38681 (arg1)->SetCaret(arg2);
38682 wxPyEndAllowThreads(__tstate);
38683 if (PyErr_Occurred()) SWIG_fail;
38684 }
38685 resultobj = SWIG_Py_Void();
38686 return resultobj;
38687 fail:
38688 return NULL;
38689 }
38690
38691
38692 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38693 PyObject *resultobj = 0;
38694 wxWindow *arg1 = (wxWindow *) 0 ;
38695 wxCaret *result = 0 ;
38696 void *argp1 = 0 ;
38697 int res1 = 0 ;
38698 PyObject *swig_obj[1] ;
38699
38700 if (!args) SWIG_fail;
38701 swig_obj[0] = args;
38702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38703 if (!SWIG_IsOK(res1)) {
38704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38705 }
38706 arg1 = reinterpret_cast< wxWindow * >(argp1);
38707 {
38708 PyThreadState* __tstate = wxPyBeginAllowThreads();
38709 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38710 wxPyEndAllowThreads(__tstate);
38711 if (PyErr_Occurred()) SWIG_fail;
38712 }
38713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38721 PyObject *resultobj = 0;
38722 wxWindow *arg1 = (wxWindow *) 0 ;
38723 int result;
38724 void *argp1 = 0 ;
38725 int res1 = 0 ;
38726 PyObject *swig_obj[1] ;
38727
38728 if (!args) SWIG_fail;
38729 swig_obj[0] = args;
38730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38731 if (!SWIG_IsOK(res1)) {
38732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38733 }
38734 arg1 = reinterpret_cast< wxWindow * >(argp1);
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38738 wxPyEndAllowThreads(__tstate);
38739 if (PyErr_Occurred()) SWIG_fail;
38740 }
38741 resultobj = SWIG_From_int(static_cast< int >(result));
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38749 PyObject *resultobj = 0;
38750 wxWindow *arg1 = (wxWindow *) 0 ;
38751 int result;
38752 void *argp1 = 0 ;
38753 int res1 = 0 ;
38754 PyObject *swig_obj[1] ;
38755
38756 if (!args) SWIG_fail;
38757 swig_obj[0] = args;
38758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38761 }
38762 arg1 = reinterpret_cast< wxWindow * >(argp1);
38763 {
38764 PyThreadState* __tstate = wxPyBeginAllowThreads();
38765 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38766 wxPyEndAllowThreads(__tstate);
38767 if (PyErr_Occurred()) SWIG_fail;
38768 }
38769 resultobj = SWIG_From_int(static_cast< int >(result));
38770 return resultobj;
38771 fail:
38772 return NULL;
38773 }
38774
38775
38776 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38777 PyObject *resultobj = 0;
38778 wxWindow *arg1 = (wxWindow *) 0 ;
38779 wxString *arg2 = 0 ;
38780 int *arg3 = (int *) 0 ;
38781 int *arg4 = (int *) 0 ;
38782 void *argp1 = 0 ;
38783 int res1 = 0 ;
38784 bool temp2 = false ;
38785 int temp3 ;
38786 int res3 = SWIG_TMPOBJ ;
38787 int temp4 ;
38788 int res4 = SWIG_TMPOBJ ;
38789 PyObject * obj0 = 0 ;
38790 PyObject * obj1 = 0 ;
38791 char * kwnames[] = {
38792 (char *) "self",(char *) "string", NULL
38793 };
38794
38795 arg3 = &temp3;
38796 arg4 = &temp4;
38797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38799 if (!SWIG_IsOK(res1)) {
38800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38801 }
38802 arg1 = reinterpret_cast< wxWindow * >(argp1);
38803 {
38804 arg2 = wxString_in_helper(obj1);
38805 if (arg2 == NULL) SWIG_fail;
38806 temp2 = true;
38807 }
38808 {
38809 PyThreadState* __tstate = wxPyBeginAllowThreads();
38810 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 resultobj = SWIG_Py_Void();
38815 if (SWIG_IsTmpObj(res3)) {
38816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38817 } else {
38818 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38820 }
38821 if (SWIG_IsTmpObj(res4)) {
38822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38823 } else {
38824 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38826 }
38827 {
38828 if (temp2)
38829 delete arg2;
38830 }
38831 return resultobj;
38832 fail:
38833 {
38834 if (temp2)
38835 delete arg2;
38836 }
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38842 PyObject *resultobj = 0;
38843 wxWindow *arg1 = (wxWindow *) 0 ;
38844 wxString *arg2 = 0 ;
38845 int *arg3 = (int *) 0 ;
38846 int *arg4 = (int *) 0 ;
38847 int *arg5 = (int *) 0 ;
38848 int *arg6 = (int *) 0 ;
38849 wxFont *arg7 = (wxFont *) NULL ;
38850 void *argp1 = 0 ;
38851 int res1 = 0 ;
38852 bool temp2 = false ;
38853 int temp3 ;
38854 int res3 = SWIG_TMPOBJ ;
38855 int temp4 ;
38856 int res4 = SWIG_TMPOBJ ;
38857 int temp5 ;
38858 int res5 = SWIG_TMPOBJ ;
38859 int temp6 ;
38860 int res6 = SWIG_TMPOBJ ;
38861 void *argp7 = 0 ;
38862 int res7 = 0 ;
38863 PyObject * obj0 = 0 ;
38864 PyObject * obj1 = 0 ;
38865 PyObject * obj2 = 0 ;
38866 char * kwnames[] = {
38867 (char *) "self",(char *) "string",(char *) "font", NULL
38868 };
38869
38870 arg3 = &temp3;
38871 arg4 = &temp4;
38872 arg5 = &temp5;
38873 arg6 = &temp6;
38874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38876 if (!SWIG_IsOK(res1)) {
38877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38878 }
38879 arg1 = reinterpret_cast< wxWindow * >(argp1);
38880 {
38881 arg2 = wxString_in_helper(obj1);
38882 if (arg2 == NULL) SWIG_fail;
38883 temp2 = true;
38884 }
38885 if (obj2) {
38886 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38887 if (!SWIG_IsOK(res7)) {
38888 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38889 }
38890 arg7 = reinterpret_cast< wxFont * >(argp7);
38891 }
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38895 wxPyEndAllowThreads(__tstate);
38896 if (PyErr_Occurred()) SWIG_fail;
38897 }
38898 resultobj = SWIG_Py_Void();
38899 if (SWIG_IsTmpObj(res3)) {
38900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38901 } else {
38902 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38904 }
38905 if (SWIG_IsTmpObj(res4)) {
38906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38907 } else {
38908 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38910 }
38911 if (SWIG_IsTmpObj(res5)) {
38912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38913 } else {
38914 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38916 }
38917 if (SWIG_IsTmpObj(res6)) {
38918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38919 } else {
38920 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38922 }
38923 {
38924 if (temp2)
38925 delete arg2;
38926 }
38927 return resultobj;
38928 fail:
38929 {
38930 if (temp2)
38931 delete arg2;
38932 }
38933 return NULL;
38934 }
38935
38936
38937 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj = 0;
38939 wxWindow *arg1 = (wxWindow *) 0 ;
38940 int *arg2 = (int *) 0 ;
38941 int *arg3 = (int *) 0 ;
38942 void *argp1 = 0 ;
38943 int res1 = 0 ;
38944 int temp2 ;
38945 int res2 = 0 ;
38946 int temp3 ;
38947 int res3 = 0 ;
38948 PyObject * obj0 = 0 ;
38949 PyObject * obj1 = 0 ;
38950 PyObject * obj2 = 0 ;
38951 char * kwnames[] = {
38952 (char *) "self",(char *) "x",(char *) "y", NULL
38953 };
38954
38955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38957 if (!SWIG_IsOK(res1)) {
38958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38959 }
38960 arg1 = reinterpret_cast< wxWindow * >(argp1);
38961 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38962 int val;
38963 int ecode = SWIG_AsVal_int(obj1, &val);
38964 if (!SWIG_IsOK(ecode)) {
38965 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38966 }
38967 temp2 = static_cast< int >(val);
38968 arg2 = &temp2;
38969 res2 = SWIG_AddTmpMask(ecode);
38970 }
38971 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38972 int val;
38973 int ecode = SWIG_AsVal_int(obj2, &val);
38974 if (!SWIG_IsOK(ecode)) {
38975 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38976 }
38977 temp3 = static_cast< int >(val);
38978 arg3 = &temp3;
38979 res3 = SWIG_AddTmpMask(ecode);
38980 }
38981 {
38982 PyThreadState* __tstate = wxPyBeginAllowThreads();
38983 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38984 wxPyEndAllowThreads(__tstate);
38985 if (PyErr_Occurred()) SWIG_fail;
38986 }
38987 resultobj = SWIG_Py_Void();
38988 if (SWIG_IsTmpObj(res2)) {
38989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38990 } else {
38991 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38993 }
38994 if (SWIG_IsTmpObj(res3)) {
38995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38996 } else {
38997 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38999 }
39000 return resultobj;
39001 fail:
39002 return NULL;
39003 }
39004
39005
39006 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39007 PyObject *resultobj = 0;
39008 wxWindow *arg1 = (wxWindow *) 0 ;
39009 int *arg2 = (int *) 0 ;
39010 int *arg3 = (int *) 0 ;
39011 void *argp1 = 0 ;
39012 int res1 = 0 ;
39013 int temp2 ;
39014 int res2 = 0 ;
39015 int temp3 ;
39016 int res3 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 PyObject * obj2 = 0 ;
39020 char * kwnames[] = {
39021 (char *) "self",(char *) "x",(char *) "y", NULL
39022 };
39023
39024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39028 }
39029 arg1 = reinterpret_cast< wxWindow * >(argp1);
39030 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39031 int val;
39032 int ecode = SWIG_AsVal_int(obj1, &val);
39033 if (!SWIG_IsOK(ecode)) {
39034 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39035 }
39036 temp2 = static_cast< int >(val);
39037 arg2 = &temp2;
39038 res2 = SWIG_AddTmpMask(ecode);
39039 }
39040 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39041 int val;
39042 int ecode = SWIG_AsVal_int(obj2, &val);
39043 if (!SWIG_IsOK(ecode)) {
39044 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39045 }
39046 temp3 = static_cast< int >(val);
39047 arg3 = &temp3;
39048 res3 = SWIG_AddTmpMask(ecode);
39049 }
39050 {
39051 PyThreadState* __tstate = wxPyBeginAllowThreads();
39052 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39053 wxPyEndAllowThreads(__tstate);
39054 if (PyErr_Occurred()) SWIG_fail;
39055 }
39056 resultobj = SWIG_Py_Void();
39057 if (SWIG_IsTmpObj(res2)) {
39058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39059 } else {
39060 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39062 }
39063 if (SWIG_IsTmpObj(res3)) {
39064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39065 } else {
39066 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39068 }
39069 return resultobj;
39070 fail:
39071 return NULL;
39072 }
39073
39074
39075 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39076 PyObject *resultobj = 0;
39077 wxWindow *arg1 = (wxWindow *) 0 ;
39078 wxPoint *arg2 = 0 ;
39079 wxPoint result;
39080 void *argp1 = 0 ;
39081 int res1 = 0 ;
39082 wxPoint temp2 ;
39083 PyObject * obj0 = 0 ;
39084 PyObject * obj1 = 0 ;
39085 char * kwnames[] = {
39086 (char *) "self",(char *) "pt", NULL
39087 };
39088
39089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39091 if (!SWIG_IsOK(res1)) {
39092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39093 }
39094 arg1 = reinterpret_cast< wxWindow * >(argp1);
39095 {
39096 arg2 = &temp2;
39097 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39098 }
39099 {
39100 PyThreadState* __tstate = wxPyBeginAllowThreads();
39101 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39102 wxPyEndAllowThreads(__tstate);
39103 if (PyErr_Occurred()) SWIG_fail;
39104 }
39105 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39106 return resultobj;
39107 fail:
39108 return NULL;
39109 }
39110
39111
39112 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39113 PyObject *resultobj = 0;
39114 wxWindow *arg1 = (wxWindow *) 0 ;
39115 wxPoint *arg2 = 0 ;
39116 wxPoint result;
39117 void *argp1 = 0 ;
39118 int res1 = 0 ;
39119 wxPoint temp2 ;
39120 PyObject * obj0 = 0 ;
39121 PyObject * obj1 = 0 ;
39122 char * kwnames[] = {
39123 (char *) "self",(char *) "pt", NULL
39124 };
39125
39126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39128 if (!SWIG_IsOK(res1)) {
39129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39130 }
39131 arg1 = reinterpret_cast< wxWindow * >(argp1);
39132 {
39133 arg2 = &temp2;
39134 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39135 }
39136 {
39137 PyThreadState* __tstate = wxPyBeginAllowThreads();
39138 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39139 wxPyEndAllowThreads(__tstate);
39140 if (PyErr_Occurred()) SWIG_fail;
39141 }
39142 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39143 return resultobj;
39144 fail:
39145 return NULL;
39146 }
39147
39148
39149 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39150 PyObject *resultobj = 0;
39151 wxWindow *arg1 = (wxWindow *) 0 ;
39152 int arg2 ;
39153 int arg3 ;
39154 wxHitTest result;
39155 void *argp1 = 0 ;
39156 int res1 = 0 ;
39157 int val2 ;
39158 int ecode2 = 0 ;
39159 int val3 ;
39160 int ecode3 = 0 ;
39161 PyObject * obj0 = 0 ;
39162 PyObject * obj1 = 0 ;
39163 PyObject * obj2 = 0 ;
39164 char * kwnames[] = {
39165 (char *) "self",(char *) "x",(char *) "y", NULL
39166 };
39167
39168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39170 if (!SWIG_IsOK(res1)) {
39171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39172 }
39173 arg1 = reinterpret_cast< wxWindow * >(argp1);
39174 ecode2 = SWIG_AsVal_int(obj1, &val2);
39175 if (!SWIG_IsOK(ecode2)) {
39176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39177 }
39178 arg2 = static_cast< int >(val2);
39179 ecode3 = SWIG_AsVal_int(obj2, &val3);
39180 if (!SWIG_IsOK(ecode3)) {
39181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39182 }
39183 arg3 = static_cast< int >(val3);
39184 {
39185 PyThreadState* __tstate = wxPyBeginAllowThreads();
39186 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39187 wxPyEndAllowThreads(__tstate);
39188 if (PyErr_Occurred()) SWIG_fail;
39189 }
39190 resultobj = SWIG_From_int(static_cast< int >(result));
39191 return resultobj;
39192 fail:
39193 return NULL;
39194 }
39195
39196
39197 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj = 0;
39199 wxWindow *arg1 = (wxWindow *) 0 ;
39200 wxPoint *arg2 = 0 ;
39201 wxHitTest result;
39202 void *argp1 = 0 ;
39203 int res1 = 0 ;
39204 wxPoint temp2 ;
39205 PyObject * obj0 = 0 ;
39206 PyObject * obj1 = 0 ;
39207 char * kwnames[] = {
39208 (char *) "self",(char *) "pt", NULL
39209 };
39210
39211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39213 if (!SWIG_IsOK(res1)) {
39214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39215 }
39216 arg1 = reinterpret_cast< wxWindow * >(argp1);
39217 {
39218 arg2 = &temp2;
39219 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39220 }
39221 {
39222 PyThreadState* __tstate = wxPyBeginAllowThreads();
39223 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39224 wxPyEndAllowThreads(__tstate);
39225 if (PyErr_Occurred()) SWIG_fail;
39226 }
39227 resultobj = SWIG_From_int(static_cast< int >(result));
39228 return resultobj;
39229 fail:
39230 return NULL;
39231 }
39232
39233
39234 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39235 PyObject *resultobj = 0;
39236 wxWindow *arg1 = (wxWindow *) 0 ;
39237 long arg2 ;
39238 wxBorder result;
39239 void *argp1 = 0 ;
39240 int res1 = 0 ;
39241 long val2 ;
39242 int ecode2 = 0 ;
39243
39244 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39246 if (!SWIG_IsOK(res1)) {
39247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39248 }
39249 arg1 = reinterpret_cast< wxWindow * >(argp1);
39250 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39251 if (!SWIG_IsOK(ecode2)) {
39252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39253 }
39254 arg2 = static_cast< long >(val2);
39255 {
39256 PyThreadState* __tstate = wxPyBeginAllowThreads();
39257 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39258 wxPyEndAllowThreads(__tstate);
39259 if (PyErr_Occurred()) SWIG_fail;
39260 }
39261 resultobj = SWIG_From_int(static_cast< int >(result));
39262 return resultobj;
39263 fail:
39264 return NULL;
39265 }
39266
39267
39268 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39269 PyObject *resultobj = 0;
39270 wxWindow *arg1 = (wxWindow *) 0 ;
39271 wxBorder result;
39272 void *argp1 = 0 ;
39273 int res1 = 0 ;
39274
39275 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39277 if (!SWIG_IsOK(res1)) {
39278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39279 }
39280 arg1 = reinterpret_cast< wxWindow * >(argp1);
39281 {
39282 PyThreadState* __tstate = wxPyBeginAllowThreads();
39283 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39284 wxPyEndAllowThreads(__tstate);
39285 if (PyErr_Occurred()) SWIG_fail;
39286 }
39287 resultobj = SWIG_From_int(static_cast< int >(result));
39288 return resultobj;
39289 fail:
39290 return NULL;
39291 }
39292
39293
39294 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39295 int argc;
39296 PyObject *argv[3];
39297
39298 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39299 --argc;
39300 if (argc == 1) {
39301 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39302 }
39303 if (argc == 2) {
39304 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39305 }
39306
39307 fail:
39308 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39309 return NULL;
39310 }
39311
39312
39313 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39314 PyObject *resultobj = 0;
39315 wxWindow *arg1 = (wxWindow *) 0 ;
39316 long arg2 = (long) wxUPDATE_UI_NONE ;
39317 void *argp1 = 0 ;
39318 int res1 = 0 ;
39319 long val2 ;
39320 int ecode2 = 0 ;
39321 PyObject * obj0 = 0 ;
39322 PyObject * obj1 = 0 ;
39323 char * kwnames[] = {
39324 (char *) "self",(char *) "flags", NULL
39325 };
39326
39327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39329 if (!SWIG_IsOK(res1)) {
39330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39331 }
39332 arg1 = reinterpret_cast< wxWindow * >(argp1);
39333 if (obj1) {
39334 ecode2 = SWIG_AsVal_long(obj1, &val2);
39335 if (!SWIG_IsOK(ecode2)) {
39336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39337 }
39338 arg2 = static_cast< long >(val2);
39339 }
39340 {
39341 PyThreadState* __tstate = wxPyBeginAllowThreads();
39342 (arg1)->UpdateWindowUI(arg2);
39343 wxPyEndAllowThreads(__tstate);
39344 if (PyErr_Occurred()) SWIG_fail;
39345 }
39346 resultobj = SWIG_Py_Void();
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39354 PyObject *resultobj = 0;
39355 wxWindow *arg1 = (wxWindow *) 0 ;
39356 wxMenu *arg2 = (wxMenu *) 0 ;
39357 int arg3 = (int) -1 ;
39358 int arg4 = (int) -1 ;
39359 bool result;
39360 void *argp1 = 0 ;
39361 int res1 = 0 ;
39362 void *argp2 = 0 ;
39363 int res2 = 0 ;
39364 int val3 ;
39365 int ecode3 = 0 ;
39366 int val4 ;
39367 int ecode4 = 0 ;
39368 PyObject * obj0 = 0 ;
39369 PyObject * obj1 = 0 ;
39370 PyObject * obj2 = 0 ;
39371 PyObject * obj3 = 0 ;
39372 char * kwnames[] = {
39373 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39374 };
39375
39376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39378 if (!SWIG_IsOK(res1)) {
39379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39380 }
39381 arg1 = reinterpret_cast< wxWindow * >(argp1);
39382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39383 if (!SWIG_IsOK(res2)) {
39384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39385 }
39386 arg2 = reinterpret_cast< wxMenu * >(argp2);
39387 if (obj2) {
39388 ecode3 = SWIG_AsVal_int(obj2, &val3);
39389 if (!SWIG_IsOK(ecode3)) {
39390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39391 }
39392 arg3 = static_cast< int >(val3);
39393 }
39394 if (obj3) {
39395 ecode4 = SWIG_AsVal_int(obj3, &val4);
39396 if (!SWIG_IsOK(ecode4)) {
39397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39398 }
39399 arg4 = static_cast< int >(val4);
39400 }
39401 {
39402 PyThreadState* __tstate = wxPyBeginAllowThreads();
39403 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39404 wxPyEndAllowThreads(__tstate);
39405 if (PyErr_Occurred()) SWIG_fail;
39406 }
39407 {
39408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39409 }
39410 return resultobj;
39411 fail:
39412 return NULL;
39413 }
39414
39415
39416 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39417 PyObject *resultobj = 0;
39418 wxWindow *arg1 = (wxWindow *) 0 ;
39419 wxMenu *arg2 = (wxMenu *) 0 ;
39420 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39421 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39422 bool result;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 void *argp2 = 0 ;
39426 int res2 = 0 ;
39427 wxPoint temp3 ;
39428 PyObject * obj0 = 0 ;
39429 PyObject * obj1 = 0 ;
39430 PyObject * obj2 = 0 ;
39431 char * kwnames[] = {
39432 (char *) "self",(char *) "menu",(char *) "pos", NULL
39433 };
39434
39435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39437 if (!SWIG_IsOK(res1)) {
39438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39439 }
39440 arg1 = reinterpret_cast< wxWindow * >(argp1);
39441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39442 if (!SWIG_IsOK(res2)) {
39443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39444 }
39445 arg2 = reinterpret_cast< wxMenu * >(argp2);
39446 if (obj2) {
39447 {
39448 arg3 = &temp3;
39449 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39450 }
39451 }
39452 {
39453 PyThreadState* __tstate = wxPyBeginAllowThreads();
39454 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39455 wxPyEndAllowThreads(__tstate);
39456 if (PyErr_Occurred()) SWIG_fail;
39457 }
39458 {
39459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39460 }
39461 return resultobj;
39462 fail:
39463 return NULL;
39464 }
39465
39466
39467 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39468 PyObject *resultobj = 0;
39469 wxWindow *arg1 = (wxWindow *) 0 ;
39470 bool result;
39471 void *argp1 = 0 ;
39472 int res1 = 0 ;
39473 PyObject *swig_obj[1] ;
39474
39475 if (!args) SWIG_fail;
39476 swig_obj[0] = args;
39477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39478 if (!SWIG_IsOK(res1)) {
39479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39480 }
39481 arg1 = reinterpret_cast< wxWindow * >(argp1);
39482 {
39483 PyThreadState* __tstate = wxPyBeginAllowThreads();
39484 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39485 wxPyEndAllowThreads(__tstate);
39486 if (PyErr_Occurred()) SWIG_fail;
39487 }
39488 {
39489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39490 }
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39498 PyObject *resultobj = 0;
39499 wxWindow *arg1 = (wxWindow *) 0 ;
39500 long result;
39501 void *argp1 = 0 ;
39502 int res1 = 0 ;
39503 PyObject *swig_obj[1] ;
39504
39505 if (!args) SWIG_fail;
39506 swig_obj[0] = args;
39507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39508 if (!SWIG_IsOK(res1)) {
39509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39510 }
39511 arg1 = reinterpret_cast< wxWindow * >(argp1);
39512 {
39513 PyThreadState* __tstate = wxPyBeginAllowThreads();
39514 result = (long)wxWindow_GetHandle(arg1);
39515 wxPyEndAllowThreads(__tstate);
39516 if (PyErr_Occurred()) SWIG_fail;
39517 }
39518 resultobj = SWIG_From_long(static_cast< long >(result));
39519 return resultobj;
39520 fail:
39521 return NULL;
39522 }
39523
39524
39525 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39526 PyObject *resultobj = 0;
39527 wxWindow *arg1 = (wxWindow *) 0 ;
39528 long arg2 ;
39529 void *argp1 = 0 ;
39530 int res1 = 0 ;
39531 long val2 ;
39532 int ecode2 = 0 ;
39533 PyObject * obj0 = 0 ;
39534 PyObject * obj1 = 0 ;
39535 char * kwnames[] = {
39536 (char *) "self",(char *) "handle", NULL
39537 };
39538
39539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39541 if (!SWIG_IsOK(res1)) {
39542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39543 }
39544 arg1 = reinterpret_cast< wxWindow * >(argp1);
39545 ecode2 = SWIG_AsVal_long(obj1, &val2);
39546 if (!SWIG_IsOK(ecode2)) {
39547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39548 }
39549 arg2 = static_cast< long >(val2);
39550 {
39551 PyThreadState* __tstate = wxPyBeginAllowThreads();
39552 wxWindow_AssociateHandle(arg1,arg2);
39553 wxPyEndAllowThreads(__tstate);
39554 if (PyErr_Occurred()) SWIG_fail;
39555 }
39556 resultobj = SWIG_Py_Void();
39557 return resultobj;
39558 fail:
39559 return NULL;
39560 }
39561
39562
39563 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39564 PyObject *resultobj = 0;
39565 wxWindow *arg1 = (wxWindow *) 0 ;
39566 void *argp1 = 0 ;
39567 int res1 = 0 ;
39568 PyObject *swig_obj[1] ;
39569
39570 if (!args) SWIG_fail;
39571 swig_obj[0] = args;
39572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39573 if (!SWIG_IsOK(res1)) {
39574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39575 }
39576 arg1 = reinterpret_cast< wxWindow * >(argp1);
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 (arg1)->DissociateHandle();
39580 wxPyEndAllowThreads(__tstate);
39581 if (PyErr_Occurred()) SWIG_fail;
39582 }
39583 resultobj = SWIG_Py_Void();
39584 return resultobj;
39585 fail:
39586 return NULL;
39587 }
39588
39589
39590 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39591 PyObject *resultobj = 0;
39592 wxWindow *arg1 = (wxWindow *) 0 ;
39593 int arg2 ;
39594 bool result;
39595 void *argp1 = 0 ;
39596 int res1 = 0 ;
39597 int val2 ;
39598 int ecode2 = 0 ;
39599 PyObject * obj0 = 0 ;
39600 PyObject * obj1 = 0 ;
39601 char * kwnames[] = {
39602 (char *) "self",(char *) "orient", NULL
39603 };
39604
39605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39607 if (!SWIG_IsOK(res1)) {
39608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39609 }
39610 arg1 = reinterpret_cast< wxWindow * >(argp1);
39611 ecode2 = SWIG_AsVal_int(obj1, &val2);
39612 if (!SWIG_IsOK(ecode2)) {
39613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39614 }
39615 arg2 = static_cast< int >(val2);
39616 {
39617 PyThreadState* __tstate = wxPyBeginAllowThreads();
39618 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39619 wxPyEndAllowThreads(__tstate);
39620 if (PyErr_Occurred()) SWIG_fail;
39621 }
39622 {
39623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39624 }
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj = 0;
39633 wxWindow *arg1 = (wxWindow *) 0 ;
39634 int arg2 ;
39635 int arg3 ;
39636 int arg4 ;
39637 int arg5 ;
39638 bool arg6 = (bool) true ;
39639 void *argp1 = 0 ;
39640 int res1 = 0 ;
39641 int val2 ;
39642 int ecode2 = 0 ;
39643 int val3 ;
39644 int ecode3 = 0 ;
39645 int val4 ;
39646 int ecode4 = 0 ;
39647 int val5 ;
39648 int ecode5 = 0 ;
39649 bool val6 ;
39650 int ecode6 = 0 ;
39651 PyObject * obj0 = 0 ;
39652 PyObject * obj1 = 0 ;
39653 PyObject * obj2 = 0 ;
39654 PyObject * obj3 = 0 ;
39655 PyObject * obj4 = 0 ;
39656 PyObject * obj5 = 0 ;
39657 char * kwnames[] = {
39658 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39659 };
39660
39661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39663 if (!SWIG_IsOK(res1)) {
39664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39665 }
39666 arg1 = reinterpret_cast< wxWindow * >(argp1);
39667 ecode2 = SWIG_AsVal_int(obj1, &val2);
39668 if (!SWIG_IsOK(ecode2)) {
39669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39670 }
39671 arg2 = static_cast< int >(val2);
39672 ecode3 = SWIG_AsVal_int(obj2, &val3);
39673 if (!SWIG_IsOK(ecode3)) {
39674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39675 }
39676 arg3 = static_cast< int >(val3);
39677 ecode4 = SWIG_AsVal_int(obj3, &val4);
39678 if (!SWIG_IsOK(ecode4)) {
39679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39680 }
39681 arg4 = static_cast< int >(val4);
39682 ecode5 = SWIG_AsVal_int(obj4, &val5);
39683 if (!SWIG_IsOK(ecode5)) {
39684 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39685 }
39686 arg5 = static_cast< int >(val5);
39687 if (obj5) {
39688 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39689 if (!SWIG_IsOK(ecode6)) {
39690 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39691 }
39692 arg6 = static_cast< bool >(val6);
39693 }
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 resultobj = SWIG_Py_Void();
39701 return resultobj;
39702 fail:
39703 return NULL;
39704 }
39705
39706
39707 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39708 PyObject *resultobj = 0;
39709 wxWindow *arg1 = (wxWindow *) 0 ;
39710 int arg2 ;
39711 int arg3 ;
39712 bool arg4 = (bool) true ;
39713 void *argp1 = 0 ;
39714 int res1 = 0 ;
39715 int val2 ;
39716 int ecode2 = 0 ;
39717 int val3 ;
39718 int ecode3 = 0 ;
39719 bool val4 ;
39720 int ecode4 = 0 ;
39721 PyObject * obj0 = 0 ;
39722 PyObject * obj1 = 0 ;
39723 PyObject * obj2 = 0 ;
39724 PyObject * obj3 = 0 ;
39725 char * kwnames[] = {
39726 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39727 };
39728
39729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39731 if (!SWIG_IsOK(res1)) {
39732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39733 }
39734 arg1 = reinterpret_cast< wxWindow * >(argp1);
39735 ecode2 = SWIG_AsVal_int(obj1, &val2);
39736 if (!SWIG_IsOK(ecode2)) {
39737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39738 }
39739 arg2 = static_cast< int >(val2);
39740 ecode3 = SWIG_AsVal_int(obj2, &val3);
39741 if (!SWIG_IsOK(ecode3)) {
39742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39743 }
39744 arg3 = static_cast< int >(val3);
39745 if (obj3) {
39746 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39747 if (!SWIG_IsOK(ecode4)) {
39748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39749 }
39750 arg4 = static_cast< bool >(val4);
39751 }
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 (arg1)->SetScrollPos(arg2,arg3,arg4);
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 resultobj = SWIG_Py_Void();
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39766 PyObject *resultobj = 0;
39767 wxWindow *arg1 = (wxWindow *) 0 ;
39768 int arg2 ;
39769 int result;
39770 void *argp1 = 0 ;
39771 int res1 = 0 ;
39772 int val2 ;
39773 int ecode2 = 0 ;
39774 PyObject * obj0 = 0 ;
39775 PyObject * obj1 = 0 ;
39776 char * kwnames[] = {
39777 (char *) "self",(char *) "orientation", NULL
39778 };
39779
39780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39782 if (!SWIG_IsOK(res1)) {
39783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39784 }
39785 arg1 = reinterpret_cast< wxWindow * >(argp1);
39786 ecode2 = SWIG_AsVal_int(obj1, &val2);
39787 if (!SWIG_IsOK(ecode2)) {
39788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39789 }
39790 arg2 = static_cast< int >(val2);
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39794 wxPyEndAllowThreads(__tstate);
39795 if (PyErr_Occurred()) SWIG_fail;
39796 }
39797 resultobj = SWIG_From_int(static_cast< int >(result));
39798 return resultobj;
39799 fail:
39800 return NULL;
39801 }
39802
39803
39804 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39805 PyObject *resultobj = 0;
39806 wxWindow *arg1 = (wxWindow *) 0 ;
39807 int arg2 ;
39808 int result;
39809 void *argp1 = 0 ;
39810 int res1 = 0 ;
39811 int val2 ;
39812 int ecode2 = 0 ;
39813 PyObject * obj0 = 0 ;
39814 PyObject * obj1 = 0 ;
39815 char * kwnames[] = {
39816 (char *) "self",(char *) "orientation", NULL
39817 };
39818
39819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39821 if (!SWIG_IsOK(res1)) {
39822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39823 }
39824 arg1 = reinterpret_cast< wxWindow * >(argp1);
39825 ecode2 = SWIG_AsVal_int(obj1, &val2);
39826 if (!SWIG_IsOK(ecode2)) {
39827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39828 }
39829 arg2 = static_cast< int >(val2);
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 resultobj = SWIG_From_int(static_cast< int >(result));
39837 return resultobj;
39838 fail:
39839 return NULL;
39840 }
39841
39842
39843 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39844 PyObject *resultobj = 0;
39845 wxWindow *arg1 = (wxWindow *) 0 ;
39846 int arg2 ;
39847 int result;
39848 void *argp1 = 0 ;
39849 int res1 = 0 ;
39850 int val2 ;
39851 int ecode2 = 0 ;
39852 PyObject * obj0 = 0 ;
39853 PyObject * obj1 = 0 ;
39854 char * kwnames[] = {
39855 (char *) "self",(char *) "orientation", NULL
39856 };
39857
39858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39860 if (!SWIG_IsOK(res1)) {
39861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39862 }
39863 arg1 = reinterpret_cast< wxWindow * >(argp1);
39864 ecode2 = SWIG_AsVal_int(obj1, &val2);
39865 if (!SWIG_IsOK(ecode2)) {
39866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39867 }
39868 arg2 = static_cast< int >(val2);
39869 {
39870 PyThreadState* __tstate = wxPyBeginAllowThreads();
39871 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39872 wxPyEndAllowThreads(__tstate);
39873 if (PyErr_Occurred()) SWIG_fail;
39874 }
39875 resultobj = SWIG_From_int(static_cast< int >(result));
39876 return resultobj;
39877 fail:
39878 return NULL;
39879 }
39880
39881
39882 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39883 PyObject *resultobj = 0;
39884 wxWindow *arg1 = (wxWindow *) 0 ;
39885 int arg2 ;
39886 int arg3 ;
39887 wxRect *arg4 = (wxRect *) NULL ;
39888 void *argp1 = 0 ;
39889 int res1 = 0 ;
39890 int val2 ;
39891 int ecode2 = 0 ;
39892 int val3 ;
39893 int ecode3 = 0 ;
39894 void *argp4 = 0 ;
39895 int res4 = 0 ;
39896 PyObject * obj0 = 0 ;
39897 PyObject * obj1 = 0 ;
39898 PyObject * obj2 = 0 ;
39899 PyObject * obj3 = 0 ;
39900 char * kwnames[] = {
39901 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39902 };
39903
39904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39906 if (!SWIG_IsOK(res1)) {
39907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39908 }
39909 arg1 = reinterpret_cast< wxWindow * >(argp1);
39910 ecode2 = SWIG_AsVal_int(obj1, &val2);
39911 if (!SWIG_IsOK(ecode2)) {
39912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39913 }
39914 arg2 = static_cast< int >(val2);
39915 ecode3 = SWIG_AsVal_int(obj2, &val3);
39916 if (!SWIG_IsOK(ecode3)) {
39917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39918 }
39919 arg3 = static_cast< int >(val3);
39920 if (obj3) {
39921 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39922 if (!SWIG_IsOK(res4)) {
39923 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39924 }
39925 arg4 = reinterpret_cast< wxRect * >(argp4);
39926 }
39927 {
39928 PyThreadState* __tstate = wxPyBeginAllowThreads();
39929 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39930 wxPyEndAllowThreads(__tstate);
39931 if (PyErr_Occurred()) SWIG_fail;
39932 }
39933 resultobj = SWIG_Py_Void();
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39941 PyObject *resultobj = 0;
39942 wxWindow *arg1 = (wxWindow *) 0 ;
39943 int arg2 ;
39944 bool result;
39945 void *argp1 = 0 ;
39946 int res1 = 0 ;
39947 int val2 ;
39948 int ecode2 = 0 ;
39949 PyObject * obj0 = 0 ;
39950 PyObject * obj1 = 0 ;
39951 char * kwnames[] = {
39952 (char *) "self",(char *) "lines", NULL
39953 };
39954
39955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39957 if (!SWIG_IsOK(res1)) {
39958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39959 }
39960 arg1 = reinterpret_cast< wxWindow * >(argp1);
39961 ecode2 = SWIG_AsVal_int(obj1, &val2);
39962 if (!SWIG_IsOK(ecode2)) {
39963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39964 }
39965 arg2 = static_cast< int >(val2);
39966 {
39967 PyThreadState* __tstate = wxPyBeginAllowThreads();
39968 result = (bool)(arg1)->ScrollLines(arg2);
39969 wxPyEndAllowThreads(__tstate);
39970 if (PyErr_Occurred()) SWIG_fail;
39971 }
39972 {
39973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39974 }
39975 return resultobj;
39976 fail:
39977 return NULL;
39978 }
39979
39980
39981 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39982 PyObject *resultobj = 0;
39983 wxWindow *arg1 = (wxWindow *) 0 ;
39984 int arg2 ;
39985 bool result;
39986 void *argp1 = 0 ;
39987 int res1 = 0 ;
39988 int val2 ;
39989 int ecode2 = 0 ;
39990 PyObject * obj0 = 0 ;
39991 PyObject * obj1 = 0 ;
39992 char * kwnames[] = {
39993 (char *) "self",(char *) "pages", NULL
39994 };
39995
39996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
39997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39998 if (!SWIG_IsOK(res1)) {
39999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40000 }
40001 arg1 = reinterpret_cast< wxWindow * >(argp1);
40002 ecode2 = SWIG_AsVal_int(obj1, &val2);
40003 if (!SWIG_IsOK(ecode2)) {
40004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40005 }
40006 arg2 = static_cast< int >(val2);
40007 {
40008 PyThreadState* __tstate = wxPyBeginAllowThreads();
40009 result = (bool)(arg1)->ScrollPages(arg2);
40010 wxPyEndAllowThreads(__tstate);
40011 if (PyErr_Occurred()) SWIG_fail;
40012 }
40013 {
40014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40015 }
40016 return resultobj;
40017 fail:
40018 return NULL;
40019 }
40020
40021
40022 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40023 PyObject *resultobj = 0;
40024 wxWindow *arg1 = (wxWindow *) 0 ;
40025 bool result;
40026 void *argp1 = 0 ;
40027 int res1 = 0 ;
40028 PyObject *swig_obj[1] ;
40029
40030 if (!args) SWIG_fail;
40031 swig_obj[0] = args;
40032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40033 if (!SWIG_IsOK(res1)) {
40034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40035 }
40036 arg1 = reinterpret_cast< wxWindow * >(argp1);
40037 {
40038 PyThreadState* __tstate = wxPyBeginAllowThreads();
40039 result = (bool)(arg1)->LineUp();
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 {
40044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40045 }
40046 return resultobj;
40047 fail:
40048 return NULL;
40049 }
40050
40051
40052 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40053 PyObject *resultobj = 0;
40054 wxWindow *arg1 = (wxWindow *) 0 ;
40055 bool result;
40056 void *argp1 = 0 ;
40057 int res1 = 0 ;
40058 PyObject *swig_obj[1] ;
40059
40060 if (!args) SWIG_fail;
40061 swig_obj[0] = args;
40062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40063 if (!SWIG_IsOK(res1)) {
40064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40065 }
40066 arg1 = reinterpret_cast< wxWindow * >(argp1);
40067 {
40068 PyThreadState* __tstate = wxPyBeginAllowThreads();
40069 result = (bool)(arg1)->LineDown();
40070 wxPyEndAllowThreads(__tstate);
40071 if (PyErr_Occurred()) SWIG_fail;
40072 }
40073 {
40074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40075 }
40076 return resultobj;
40077 fail:
40078 return NULL;
40079 }
40080
40081
40082 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40083 PyObject *resultobj = 0;
40084 wxWindow *arg1 = (wxWindow *) 0 ;
40085 bool result;
40086 void *argp1 = 0 ;
40087 int res1 = 0 ;
40088 PyObject *swig_obj[1] ;
40089
40090 if (!args) SWIG_fail;
40091 swig_obj[0] = args;
40092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40093 if (!SWIG_IsOK(res1)) {
40094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40095 }
40096 arg1 = reinterpret_cast< wxWindow * >(argp1);
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (bool)(arg1)->PageUp();
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40113 PyObject *resultobj = 0;
40114 wxWindow *arg1 = (wxWindow *) 0 ;
40115 bool result;
40116 void *argp1 = 0 ;
40117 int res1 = 0 ;
40118 PyObject *swig_obj[1] ;
40119
40120 if (!args) SWIG_fail;
40121 swig_obj[0] = args;
40122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40123 if (!SWIG_IsOK(res1)) {
40124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40125 }
40126 arg1 = reinterpret_cast< wxWindow * >(argp1);
40127 {
40128 PyThreadState* __tstate = wxPyBeginAllowThreads();
40129 result = (bool)(arg1)->PageDown();
40130 wxPyEndAllowThreads(__tstate);
40131 if (PyErr_Occurred()) SWIG_fail;
40132 }
40133 {
40134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40135 }
40136 return resultobj;
40137 fail:
40138 return NULL;
40139 }
40140
40141
40142 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40143 PyObject *resultobj = 0;
40144 wxWindow *arg1 = (wxWindow *) 0 ;
40145 wxString *arg2 = 0 ;
40146 void *argp1 = 0 ;
40147 int res1 = 0 ;
40148 bool temp2 = false ;
40149 PyObject * obj0 = 0 ;
40150 PyObject * obj1 = 0 ;
40151 char * kwnames[] = {
40152 (char *) "self",(char *) "text", NULL
40153 };
40154
40155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40157 if (!SWIG_IsOK(res1)) {
40158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40159 }
40160 arg1 = reinterpret_cast< wxWindow * >(argp1);
40161 {
40162 arg2 = wxString_in_helper(obj1);
40163 if (arg2 == NULL) SWIG_fail;
40164 temp2 = true;
40165 }
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 (arg1)->SetHelpText((wxString const &)*arg2);
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 resultobj = SWIG_Py_Void();
40173 {
40174 if (temp2)
40175 delete arg2;
40176 }
40177 return resultobj;
40178 fail:
40179 {
40180 if (temp2)
40181 delete arg2;
40182 }
40183 return NULL;
40184 }
40185
40186
40187 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40188 PyObject *resultobj = 0;
40189 wxWindow *arg1 = (wxWindow *) 0 ;
40190 wxString *arg2 = 0 ;
40191 void *argp1 = 0 ;
40192 int res1 = 0 ;
40193 bool temp2 = false ;
40194 PyObject * obj0 = 0 ;
40195 PyObject * obj1 = 0 ;
40196 char * kwnames[] = {
40197 (char *) "self",(char *) "text", NULL
40198 };
40199
40200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40202 if (!SWIG_IsOK(res1)) {
40203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40204 }
40205 arg1 = reinterpret_cast< wxWindow * >(argp1);
40206 {
40207 arg2 = wxString_in_helper(obj1);
40208 if (arg2 == NULL) SWIG_fail;
40209 temp2 = true;
40210 }
40211 {
40212 PyThreadState* __tstate = wxPyBeginAllowThreads();
40213 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40214 wxPyEndAllowThreads(__tstate);
40215 if (PyErr_Occurred()) SWIG_fail;
40216 }
40217 resultobj = SWIG_Py_Void();
40218 {
40219 if (temp2)
40220 delete arg2;
40221 }
40222 return resultobj;
40223 fail:
40224 {
40225 if (temp2)
40226 delete arg2;
40227 }
40228 return NULL;
40229 }
40230
40231
40232 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40233 PyObject *resultobj = 0;
40234 wxWindow *arg1 = (wxWindow *) 0 ;
40235 wxPoint *arg2 = 0 ;
40236 wxHelpEvent::Origin arg3 ;
40237 wxString result;
40238 void *argp1 = 0 ;
40239 int res1 = 0 ;
40240 wxPoint temp2 ;
40241 void *argp3 ;
40242 int res3 = 0 ;
40243 PyObject * obj0 = 0 ;
40244 PyObject * obj1 = 0 ;
40245 PyObject * obj2 = 0 ;
40246 char * kwnames[] = {
40247 (char *) "self",(char *) "pt",(char *) "origin", NULL
40248 };
40249
40250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40252 if (!SWIG_IsOK(res1)) {
40253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40254 }
40255 arg1 = reinterpret_cast< wxWindow * >(argp1);
40256 {
40257 arg2 = &temp2;
40258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40259 }
40260 {
40261 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40262 if (!SWIG_IsOK(res3)) {
40263 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40264 }
40265 if (!argp3) {
40266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40267 } else {
40268 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40269 arg3 = *temp;
40270 if (SWIG_IsNewObj(res3)) delete temp;
40271 }
40272 }
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40276 wxPyEndAllowThreads(__tstate);
40277 if (PyErr_Occurred()) SWIG_fail;
40278 }
40279 {
40280 #if wxUSE_UNICODE
40281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40282 #else
40283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40284 #endif
40285 }
40286 return resultobj;
40287 fail:
40288 return NULL;
40289 }
40290
40291
40292 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40293 PyObject *resultobj = 0;
40294 wxWindow *arg1 = (wxWindow *) 0 ;
40295 wxString result;
40296 void *argp1 = 0 ;
40297 int res1 = 0 ;
40298 PyObject *swig_obj[1] ;
40299
40300 if (!args) SWIG_fail;
40301 swig_obj[0] = args;
40302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40303 if (!SWIG_IsOK(res1)) {
40304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40305 }
40306 arg1 = reinterpret_cast< wxWindow * >(argp1);
40307 {
40308 PyThreadState* __tstate = wxPyBeginAllowThreads();
40309 result = ((wxWindow const *)arg1)->GetHelpText();
40310 wxPyEndAllowThreads(__tstate);
40311 if (PyErr_Occurred()) SWIG_fail;
40312 }
40313 {
40314 #if wxUSE_UNICODE
40315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40316 #else
40317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40318 #endif
40319 }
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40327 PyObject *resultobj = 0;
40328 wxWindow *arg1 = (wxWindow *) 0 ;
40329 wxString *arg2 = 0 ;
40330 void *argp1 = 0 ;
40331 int res1 = 0 ;
40332 bool temp2 = false ;
40333 PyObject * obj0 = 0 ;
40334 PyObject * obj1 = 0 ;
40335 char * kwnames[] = {
40336 (char *) "self",(char *) "tip", NULL
40337 };
40338
40339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40341 if (!SWIG_IsOK(res1)) {
40342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40343 }
40344 arg1 = reinterpret_cast< wxWindow * >(argp1);
40345 {
40346 arg2 = wxString_in_helper(obj1);
40347 if (arg2 == NULL) SWIG_fail;
40348 temp2 = true;
40349 }
40350 {
40351 PyThreadState* __tstate = wxPyBeginAllowThreads();
40352 (arg1)->SetToolTip((wxString const &)*arg2);
40353 wxPyEndAllowThreads(__tstate);
40354 if (PyErr_Occurred()) SWIG_fail;
40355 }
40356 resultobj = SWIG_Py_Void();
40357 {
40358 if (temp2)
40359 delete arg2;
40360 }
40361 return resultobj;
40362 fail:
40363 {
40364 if (temp2)
40365 delete arg2;
40366 }
40367 return NULL;
40368 }
40369
40370
40371 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40372 PyObject *resultobj = 0;
40373 wxWindow *arg1 = (wxWindow *) 0 ;
40374 wxToolTip *arg2 = (wxToolTip *) 0 ;
40375 void *argp1 = 0 ;
40376 int res1 = 0 ;
40377 int res2 = 0 ;
40378 PyObject * obj0 = 0 ;
40379 PyObject * obj1 = 0 ;
40380 char * kwnames[] = {
40381 (char *) "self",(char *) "tip", NULL
40382 };
40383
40384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40386 if (!SWIG_IsOK(res1)) {
40387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40388 }
40389 arg1 = reinterpret_cast< wxWindow * >(argp1);
40390 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40391 if (!SWIG_IsOK(res2)) {
40392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40393 }
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 (arg1)->SetToolTip(arg2);
40397 wxPyEndAllowThreads(__tstate);
40398 if (PyErr_Occurred()) SWIG_fail;
40399 }
40400 resultobj = SWIG_Py_Void();
40401 return resultobj;
40402 fail:
40403 return NULL;
40404 }
40405
40406
40407 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40408 PyObject *resultobj = 0;
40409 wxWindow *arg1 = (wxWindow *) 0 ;
40410 wxToolTip *result = 0 ;
40411 void *argp1 = 0 ;
40412 int res1 = 0 ;
40413 PyObject *swig_obj[1] ;
40414
40415 if (!args) SWIG_fail;
40416 swig_obj[0] = args;
40417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40418 if (!SWIG_IsOK(res1)) {
40419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40420 }
40421 arg1 = reinterpret_cast< wxWindow * >(argp1);
40422 {
40423 PyThreadState* __tstate = wxPyBeginAllowThreads();
40424 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40425 wxPyEndAllowThreads(__tstate);
40426 if (PyErr_Occurred()) SWIG_fail;
40427 }
40428 {
40429 resultobj = wxPyMake_wxObject(result, (bool)0);
40430 }
40431 return resultobj;
40432 fail:
40433 return NULL;
40434 }
40435
40436
40437 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj = 0;
40439 wxWindow *arg1 = (wxWindow *) 0 ;
40440 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40441 void *argp1 = 0 ;
40442 int res1 = 0 ;
40443 int res2 = 0 ;
40444 PyObject * obj0 = 0 ;
40445 PyObject * obj1 = 0 ;
40446 char * kwnames[] = {
40447 (char *) "self",(char *) "dropTarget", NULL
40448 };
40449
40450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40452 if (!SWIG_IsOK(res1)) {
40453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40454 }
40455 arg1 = reinterpret_cast< wxWindow * >(argp1);
40456 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40457 if (!SWIG_IsOK(res2)) {
40458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40459 }
40460 {
40461 PyThreadState* __tstate = wxPyBeginAllowThreads();
40462 (arg1)->SetDropTarget(arg2);
40463 wxPyEndAllowThreads(__tstate);
40464 if (PyErr_Occurred()) SWIG_fail;
40465 }
40466 resultobj = SWIG_Py_Void();
40467 return resultobj;
40468 fail:
40469 return NULL;
40470 }
40471
40472
40473 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40474 PyObject *resultobj = 0;
40475 wxWindow *arg1 = (wxWindow *) 0 ;
40476 wxPyDropTarget *result = 0 ;
40477 void *argp1 = 0 ;
40478 int res1 = 0 ;
40479 PyObject *swig_obj[1] ;
40480
40481 if (!args) SWIG_fail;
40482 swig_obj[0] = args;
40483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40484 if (!SWIG_IsOK(res1)) {
40485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40486 }
40487 arg1 = reinterpret_cast< wxWindow * >(argp1);
40488 {
40489 PyThreadState* __tstate = wxPyBeginAllowThreads();
40490 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40491 wxPyEndAllowThreads(__tstate);
40492 if (PyErr_Occurred()) SWIG_fail;
40493 }
40494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40495 return resultobj;
40496 fail:
40497 return NULL;
40498 }
40499
40500
40501 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40502 PyObject *resultobj = 0;
40503 wxWindow *arg1 = (wxWindow *) 0 ;
40504 bool arg2 ;
40505 void *argp1 = 0 ;
40506 int res1 = 0 ;
40507 bool val2 ;
40508 int ecode2 = 0 ;
40509 PyObject * obj0 = 0 ;
40510 PyObject * obj1 = 0 ;
40511 char * kwnames[] = {
40512 (char *) "self",(char *) "accept", NULL
40513 };
40514
40515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40517 if (!SWIG_IsOK(res1)) {
40518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40519 }
40520 arg1 = reinterpret_cast< wxWindow * >(argp1);
40521 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40522 if (!SWIG_IsOK(ecode2)) {
40523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40524 }
40525 arg2 = static_cast< bool >(val2);
40526 {
40527 PyThreadState* __tstate = wxPyBeginAllowThreads();
40528 wxWindow_DragAcceptFiles(arg1,arg2);
40529 wxPyEndAllowThreads(__tstate);
40530 if (PyErr_Occurred()) SWIG_fail;
40531 }
40532 resultobj = SWIG_Py_Void();
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40540 PyObject *resultobj = 0;
40541 wxWindow *arg1 = (wxWindow *) 0 ;
40542 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40543 void *argp1 = 0 ;
40544 int res1 = 0 ;
40545 int res2 = 0 ;
40546 PyObject * obj0 = 0 ;
40547 PyObject * obj1 = 0 ;
40548 char * kwnames[] = {
40549 (char *) "self",(char *) "constraints", NULL
40550 };
40551
40552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40554 if (!SWIG_IsOK(res1)) {
40555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40556 }
40557 arg1 = reinterpret_cast< wxWindow * >(argp1);
40558 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40559 if (!SWIG_IsOK(res2)) {
40560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40561 }
40562 {
40563 PyThreadState* __tstate = wxPyBeginAllowThreads();
40564 (arg1)->SetConstraints(arg2);
40565 wxPyEndAllowThreads(__tstate);
40566 if (PyErr_Occurred()) SWIG_fail;
40567 }
40568 resultobj = SWIG_Py_Void();
40569 return resultobj;
40570 fail:
40571 return NULL;
40572 }
40573
40574
40575 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40576 PyObject *resultobj = 0;
40577 wxWindow *arg1 = (wxWindow *) 0 ;
40578 wxLayoutConstraints *result = 0 ;
40579 void *argp1 = 0 ;
40580 int res1 = 0 ;
40581 PyObject *swig_obj[1] ;
40582
40583 if (!args) SWIG_fail;
40584 swig_obj[0] = args;
40585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40586 if (!SWIG_IsOK(res1)) {
40587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40588 }
40589 arg1 = reinterpret_cast< wxWindow * >(argp1);
40590 {
40591 PyThreadState* __tstate = wxPyBeginAllowThreads();
40592 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40593 wxPyEndAllowThreads(__tstate);
40594 if (PyErr_Occurred()) SWIG_fail;
40595 }
40596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40597 return resultobj;
40598 fail:
40599 return NULL;
40600 }
40601
40602
40603 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40604 PyObject *resultobj = 0;
40605 wxWindow *arg1 = (wxWindow *) 0 ;
40606 bool arg2 ;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 bool val2 ;
40610 int ecode2 = 0 ;
40611 PyObject * obj0 = 0 ;
40612 PyObject * obj1 = 0 ;
40613 char * kwnames[] = {
40614 (char *) "self",(char *) "autoLayout", NULL
40615 };
40616
40617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40619 if (!SWIG_IsOK(res1)) {
40620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40621 }
40622 arg1 = reinterpret_cast< wxWindow * >(argp1);
40623 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40624 if (!SWIG_IsOK(ecode2)) {
40625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40626 }
40627 arg2 = static_cast< bool >(val2);
40628 {
40629 PyThreadState* __tstate = wxPyBeginAllowThreads();
40630 (arg1)->SetAutoLayout(arg2);
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 resultobj = SWIG_Py_Void();
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40642 PyObject *resultobj = 0;
40643 wxWindow *arg1 = (wxWindow *) 0 ;
40644 bool result;
40645 void *argp1 = 0 ;
40646 int res1 = 0 ;
40647 PyObject *swig_obj[1] ;
40648
40649 if (!args) SWIG_fail;
40650 swig_obj[0] = args;
40651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40652 if (!SWIG_IsOK(res1)) {
40653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40654 }
40655 arg1 = reinterpret_cast< wxWindow * >(argp1);
40656 {
40657 PyThreadState* __tstate = wxPyBeginAllowThreads();
40658 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 {
40663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40664 }
40665 return resultobj;
40666 fail:
40667 return NULL;
40668 }
40669
40670
40671 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40672 PyObject *resultobj = 0;
40673 wxWindow *arg1 = (wxWindow *) 0 ;
40674 bool result;
40675 void *argp1 = 0 ;
40676 int res1 = 0 ;
40677 PyObject *swig_obj[1] ;
40678
40679 if (!args) SWIG_fail;
40680 swig_obj[0] = args;
40681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40682 if (!SWIG_IsOK(res1)) {
40683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40684 }
40685 arg1 = reinterpret_cast< wxWindow * >(argp1);
40686 {
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 result = (bool)(arg1)->Layout();
40689 wxPyEndAllowThreads(__tstate);
40690 if (PyErr_Occurred()) SWIG_fail;
40691 }
40692 {
40693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40694 }
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40702 PyObject *resultobj = 0;
40703 wxWindow *arg1 = (wxWindow *) 0 ;
40704 wxSizer *arg2 = (wxSizer *) 0 ;
40705 bool arg3 = (bool) true ;
40706 void *argp1 = 0 ;
40707 int res1 = 0 ;
40708 int res2 = 0 ;
40709 bool val3 ;
40710 int ecode3 = 0 ;
40711 PyObject * obj0 = 0 ;
40712 PyObject * obj1 = 0 ;
40713 PyObject * obj2 = 0 ;
40714 char * kwnames[] = {
40715 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40716 };
40717
40718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40720 if (!SWIG_IsOK(res1)) {
40721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40722 }
40723 arg1 = reinterpret_cast< wxWindow * >(argp1);
40724 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40725 if (!SWIG_IsOK(res2)) {
40726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40727 }
40728 if (obj2) {
40729 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40730 if (!SWIG_IsOK(ecode3)) {
40731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40732 }
40733 arg3 = static_cast< bool >(val3);
40734 }
40735 {
40736 PyThreadState* __tstate = wxPyBeginAllowThreads();
40737 (arg1)->SetSizer(arg2,arg3);
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 resultobj = SWIG_Py_Void();
40742 return resultobj;
40743 fail:
40744 return NULL;
40745 }
40746
40747
40748 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40749 PyObject *resultobj = 0;
40750 wxWindow *arg1 = (wxWindow *) 0 ;
40751 wxSizer *arg2 = (wxSizer *) 0 ;
40752 bool arg3 = (bool) true ;
40753 void *argp1 = 0 ;
40754 int res1 = 0 ;
40755 int res2 = 0 ;
40756 bool val3 ;
40757 int ecode3 = 0 ;
40758 PyObject * obj0 = 0 ;
40759 PyObject * obj1 = 0 ;
40760 PyObject * obj2 = 0 ;
40761 char * kwnames[] = {
40762 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40763 };
40764
40765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40767 if (!SWIG_IsOK(res1)) {
40768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40769 }
40770 arg1 = reinterpret_cast< wxWindow * >(argp1);
40771 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40772 if (!SWIG_IsOK(res2)) {
40773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40774 }
40775 if (obj2) {
40776 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40777 if (!SWIG_IsOK(ecode3)) {
40778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40779 }
40780 arg3 = static_cast< bool >(val3);
40781 }
40782 {
40783 PyThreadState* __tstate = wxPyBeginAllowThreads();
40784 (arg1)->SetSizerAndFit(arg2,arg3);
40785 wxPyEndAllowThreads(__tstate);
40786 if (PyErr_Occurred()) SWIG_fail;
40787 }
40788 resultobj = SWIG_Py_Void();
40789 return resultobj;
40790 fail:
40791 return NULL;
40792 }
40793
40794
40795 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40796 PyObject *resultobj = 0;
40797 wxWindow *arg1 = (wxWindow *) 0 ;
40798 wxSizer *result = 0 ;
40799 void *argp1 = 0 ;
40800 int res1 = 0 ;
40801 PyObject *swig_obj[1] ;
40802
40803 if (!args) SWIG_fail;
40804 swig_obj[0] = args;
40805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40806 if (!SWIG_IsOK(res1)) {
40807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40808 }
40809 arg1 = reinterpret_cast< wxWindow * >(argp1);
40810 {
40811 PyThreadState* __tstate = wxPyBeginAllowThreads();
40812 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40813 wxPyEndAllowThreads(__tstate);
40814 if (PyErr_Occurred()) SWIG_fail;
40815 }
40816 {
40817 resultobj = wxPyMake_wxObject(result, (bool)0);
40818 }
40819 return resultobj;
40820 fail:
40821 return NULL;
40822 }
40823
40824
40825 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40826 PyObject *resultobj = 0;
40827 wxWindow *arg1 = (wxWindow *) 0 ;
40828 wxSizer *arg2 = (wxSizer *) 0 ;
40829 void *argp1 = 0 ;
40830 int res1 = 0 ;
40831 void *argp2 = 0 ;
40832 int res2 = 0 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char * kwnames[] = {
40836 (char *) "self",(char *) "sizer", NULL
40837 };
40838
40839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40841 if (!SWIG_IsOK(res1)) {
40842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40843 }
40844 arg1 = reinterpret_cast< wxWindow * >(argp1);
40845 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40846 if (!SWIG_IsOK(res2)) {
40847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40848 }
40849 arg2 = reinterpret_cast< wxSizer * >(argp2);
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 (arg1)->SetContainingSizer(arg2);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 resultobj = SWIG_Py_Void();
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40864 PyObject *resultobj = 0;
40865 wxWindow *arg1 = (wxWindow *) 0 ;
40866 wxSizer *result = 0 ;
40867 void *argp1 = 0 ;
40868 int res1 = 0 ;
40869 PyObject *swig_obj[1] ;
40870
40871 if (!args) SWIG_fail;
40872 swig_obj[0] = args;
40873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40874 if (!SWIG_IsOK(res1)) {
40875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40876 }
40877 arg1 = reinterpret_cast< wxWindow * >(argp1);
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40881 wxPyEndAllowThreads(__tstate);
40882 if (PyErr_Occurred()) SWIG_fail;
40883 }
40884 {
40885 resultobj = wxPyMake_wxObject(result, (bool)0);
40886 }
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40894 PyObject *resultobj = 0;
40895 wxWindow *arg1 = (wxWindow *) 0 ;
40896 void *argp1 = 0 ;
40897 int res1 = 0 ;
40898 PyObject *swig_obj[1] ;
40899
40900 if (!args) SWIG_fail;
40901 swig_obj[0] = args;
40902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40903 if (!SWIG_IsOK(res1)) {
40904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40905 }
40906 arg1 = reinterpret_cast< wxWindow * >(argp1);
40907 {
40908 PyThreadState* __tstate = wxPyBeginAllowThreads();
40909 (arg1)->InheritAttributes();
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 resultobj = SWIG_Py_Void();
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40921 PyObject *resultobj = 0;
40922 wxWindow *arg1 = (wxWindow *) 0 ;
40923 bool result;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 PyObject *swig_obj[1] ;
40927
40928 if (!args) SWIG_fail;
40929 swig_obj[0] = args;
40930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40931 if (!SWIG_IsOK(res1)) {
40932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40933 }
40934 arg1 = reinterpret_cast< wxWindow * >(argp1);
40935 {
40936 PyThreadState* __tstate = wxPyBeginAllowThreads();
40937 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40938 wxPyEndAllowThreads(__tstate);
40939 if (PyErr_Occurred()) SWIG_fail;
40940 }
40941 {
40942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40943 }
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40951 PyObject *resultobj = 0;
40952 wxWindow *arg1 = (wxWindow *) 0 ;
40953 bool result;
40954 void *argp1 = 0 ;
40955 int res1 = 0 ;
40956 PyObject *swig_obj[1] ;
40957
40958 if (!args) SWIG_fail;
40959 swig_obj[0] = args;
40960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40961 if (!SWIG_IsOK(res1)) {
40962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40963 }
40964 arg1 = reinterpret_cast< wxWindow * >(argp1);
40965 {
40966 PyThreadState* __tstate = wxPyBeginAllowThreads();
40967 result = (bool)(arg1)->CanSetTransparent();
40968 wxPyEndAllowThreads(__tstate);
40969 if (PyErr_Occurred()) SWIG_fail;
40970 }
40971 {
40972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40973 }
40974 return resultobj;
40975 fail:
40976 return NULL;
40977 }
40978
40979
40980 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40981 PyObject *resultobj = 0;
40982 wxWindow *arg1 = (wxWindow *) 0 ;
40983 byte arg2 ;
40984 bool result;
40985 void *argp1 = 0 ;
40986 int res1 = 0 ;
40987 unsigned char val2 ;
40988 int ecode2 = 0 ;
40989 PyObject * obj0 = 0 ;
40990 PyObject * obj1 = 0 ;
40991 char * kwnames[] = {
40992 (char *) "self",(char *) "alpha", NULL
40993 };
40994
40995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
40996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40997 if (!SWIG_IsOK(res1)) {
40998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40999 }
41000 arg1 = reinterpret_cast< wxWindow * >(argp1);
41001 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41002 if (!SWIG_IsOK(ecode2)) {
41003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41004 }
41005 arg2 = static_cast< byte >(val2);
41006 {
41007 PyThreadState* __tstate = wxPyBeginAllowThreads();
41008 result = (bool)(arg1)->SetTransparent(arg2);
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 {
41013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41014 }
41015 return resultobj;
41016 fail:
41017 return NULL;
41018 }
41019
41020
41021 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41022 PyObject *obj;
41023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41024 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41025 return SWIG_Py_Void();
41026 }
41027
41028 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41029 return SWIG_Python_InitShadowInstance(args);
41030 }
41031
41032 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41033 PyObject *resultobj = 0;
41034 long arg1 ;
41035 wxWindow *arg2 = (wxWindow *) NULL ;
41036 wxWindow *result = 0 ;
41037 long val1 ;
41038 int ecode1 = 0 ;
41039 void *argp2 = 0 ;
41040 int res2 = 0 ;
41041 PyObject * obj0 = 0 ;
41042 PyObject * obj1 = 0 ;
41043 char * kwnames[] = {
41044 (char *) "id",(char *) "parent", NULL
41045 };
41046
41047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41048 ecode1 = SWIG_AsVal_long(obj0, &val1);
41049 if (!SWIG_IsOK(ecode1)) {
41050 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41051 }
41052 arg1 = static_cast< long >(val1);
41053 if (obj1) {
41054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41055 if (!SWIG_IsOK(res2)) {
41056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41057 }
41058 arg2 = reinterpret_cast< wxWindow * >(argp2);
41059 }
41060 {
41061 if (!wxPyCheckForApp()) SWIG_fail;
41062 PyThreadState* __tstate = wxPyBeginAllowThreads();
41063 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41064 wxPyEndAllowThreads(__tstate);
41065 if (PyErr_Occurred()) SWIG_fail;
41066 }
41067 {
41068 resultobj = wxPyMake_wxObject(result, 0);
41069 }
41070 return resultobj;
41071 fail:
41072 return NULL;
41073 }
41074
41075
41076 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41077 PyObject *resultobj = 0;
41078 wxString *arg1 = 0 ;
41079 wxWindow *arg2 = (wxWindow *) NULL ;
41080 wxWindow *result = 0 ;
41081 bool temp1 = false ;
41082 void *argp2 = 0 ;
41083 int res2 = 0 ;
41084 PyObject * obj0 = 0 ;
41085 PyObject * obj1 = 0 ;
41086 char * kwnames[] = {
41087 (char *) "name",(char *) "parent", NULL
41088 };
41089
41090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41091 {
41092 arg1 = wxString_in_helper(obj0);
41093 if (arg1 == NULL) SWIG_fail;
41094 temp1 = true;
41095 }
41096 if (obj1) {
41097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41098 if (!SWIG_IsOK(res2)) {
41099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41100 }
41101 arg2 = reinterpret_cast< wxWindow * >(argp2);
41102 }
41103 {
41104 if (!wxPyCheckForApp()) SWIG_fail;
41105 PyThreadState* __tstate = wxPyBeginAllowThreads();
41106 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 {
41111 resultobj = wxPyMake_wxObject(result, 0);
41112 }
41113 {
41114 if (temp1)
41115 delete arg1;
41116 }
41117 return resultobj;
41118 fail:
41119 {
41120 if (temp1)
41121 delete arg1;
41122 }
41123 return NULL;
41124 }
41125
41126
41127 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41128 PyObject *resultobj = 0;
41129 wxString *arg1 = 0 ;
41130 wxWindow *arg2 = (wxWindow *) NULL ;
41131 wxWindow *result = 0 ;
41132 bool temp1 = false ;
41133 void *argp2 = 0 ;
41134 int res2 = 0 ;
41135 PyObject * obj0 = 0 ;
41136 PyObject * obj1 = 0 ;
41137 char * kwnames[] = {
41138 (char *) "label",(char *) "parent", NULL
41139 };
41140
41141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41142 {
41143 arg1 = wxString_in_helper(obj0);
41144 if (arg1 == NULL) SWIG_fail;
41145 temp1 = true;
41146 }
41147 if (obj1) {
41148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41149 if (!SWIG_IsOK(res2)) {
41150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41151 }
41152 arg2 = reinterpret_cast< wxWindow * >(argp2);
41153 }
41154 {
41155 if (!wxPyCheckForApp()) SWIG_fail;
41156 PyThreadState* __tstate = wxPyBeginAllowThreads();
41157 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41158 wxPyEndAllowThreads(__tstate);
41159 if (PyErr_Occurred()) SWIG_fail;
41160 }
41161 {
41162 resultobj = wxPyMake_wxObject(result, 0);
41163 }
41164 {
41165 if (temp1)
41166 delete arg1;
41167 }
41168 return resultobj;
41169 fail:
41170 {
41171 if (temp1)
41172 delete arg1;
41173 }
41174 return NULL;
41175 }
41176
41177
41178 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41179 PyObject *resultobj = 0;
41180 wxWindow *arg1 = (wxWindow *) 0 ;
41181 unsigned long arg2 ;
41182 wxWindow *result = 0 ;
41183 void *argp1 = 0 ;
41184 int res1 = 0 ;
41185 unsigned long val2 ;
41186 int ecode2 = 0 ;
41187 PyObject * obj0 = 0 ;
41188 PyObject * obj1 = 0 ;
41189 char * kwnames[] = {
41190 (char *) "parent",(char *) "_hWnd", NULL
41191 };
41192
41193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41195 if (!SWIG_IsOK(res1)) {
41196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41197 }
41198 arg1 = reinterpret_cast< wxWindow * >(argp1);
41199 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41200 if (!SWIG_IsOK(ecode2)) {
41201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41202 }
41203 arg2 = static_cast< unsigned long >(val2);
41204 {
41205 PyThreadState* __tstate = wxPyBeginAllowThreads();
41206 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41207 wxPyEndAllowThreads(__tstate);
41208 if (PyErr_Occurred()) SWIG_fail;
41209 }
41210 {
41211 resultobj = wxPyMake_wxObject(result, 0);
41212 }
41213 return resultobj;
41214 fail:
41215 return NULL;
41216 }
41217
41218
41219 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41220 PyObject *resultobj = 0;
41221 PyObject *result = 0 ;
41222
41223 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41224 {
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 result = (PyObject *)GetTopLevelWindows();
41227 wxPyEndAllowThreads(__tstate);
41228 if (PyErr_Occurred()) SWIG_fail;
41229 }
41230 resultobj = result;
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41238 PyObject *resultobj = 0;
41239 wxValidator *result = 0 ;
41240
41241 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (wxValidator *)new wxValidator();
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41249 return resultobj;
41250 fail:
41251 return NULL;
41252 }
41253
41254
41255 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41256 PyObject *resultobj = 0;
41257 wxValidator *arg1 = (wxValidator *) 0 ;
41258 wxValidator *result = 0 ;
41259 void *argp1 = 0 ;
41260 int res1 = 0 ;
41261 PyObject *swig_obj[1] ;
41262
41263 if (!args) SWIG_fail;
41264 swig_obj[0] = args;
41265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41266 if (!SWIG_IsOK(res1)) {
41267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41268 }
41269 arg1 = reinterpret_cast< wxValidator * >(argp1);
41270 {
41271 PyThreadState* __tstate = wxPyBeginAllowThreads();
41272 result = (wxValidator *)(arg1)->Clone();
41273 wxPyEndAllowThreads(__tstate);
41274 if (PyErr_Occurred()) SWIG_fail;
41275 }
41276 {
41277 resultobj = wxPyMake_wxObject(result, 0);
41278 }
41279 return resultobj;
41280 fail:
41281 return NULL;
41282 }
41283
41284
41285 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41286 PyObject *resultobj = 0;
41287 wxValidator *arg1 = (wxValidator *) 0 ;
41288 wxWindow *arg2 = (wxWindow *) 0 ;
41289 bool result;
41290 void *argp1 = 0 ;
41291 int res1 = 0 ;
41292 void *argp2 = 0 ;
41293 int res2 = 0 ;
41294 PyObject * obj0 = 0 ;
41295 PyObject * obj1 = 0 ;
41296 char * kwnames[] = {
41297 (char *) "self",(char *) "parent", NULL
41298 };
41299
41300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41302 if (!SWIG_IsOK(res1)) {
41303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41304 }
41305 arg1 = reinterpret_cast< wxValidator * >(argp1);
41306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41307 if (!SWIG_IsOK(res2)) {
41308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41309 }
41310 arg2 = reinterpret_cast< wxWindow * >(argp2);
41311 {
41312 PyThreadState* __tstate = wxPyBeginAllowThreads();
41313 result = (bool)(arg1)->Validate(arg2);
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 {
41318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41319 }
41320 return resultobj;
41321 fail:
41322 return NULL;
41323 }
41324
41325
41326 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41327 PyObject *resultobj = 0;
41328 wxValidator *arg1 = (wxValidator *) 0 ;
41329 bool result;
41330 void *argp1 = 0 ;
41331 int res1 = 0 ;
41332 PyObject *swig_obj[1] ;
41333
41334 if (!args) SWIG_fail;
41335 swig_obj[0] = args;
41336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41337 if (!SWIG_IsOK(res1)) {
41338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41339 }
41340 arg1 = reinterpret_cast< wxValidator * >(argp1);
41341 {
41342 PyThreadState* __tstate = wxPyBeginAllowThreads();
41343 result = (bool)(arg1)->TransferToWindow();
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 {
41348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41349 }
41350 return resultobj;
41351 fail:
41352 return NULL;
41353 }
41354
41355
41356 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41357 PyObject *resultobj = 0;
41358 wxValidator *arg1 = (wxValidator *) 0 ;
41359 bool result;
41360 void *argp1 = 0 ;
41361 int res1 = 0 ;
41362 PyObject *swig_obj[1] ;
41363
41364 if (!args) SWIG_fail;
41365 swig_obj[0] = args;
41366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41367 if (!SWIG_IsOK(res1)) {
41368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41369 }
41370 arg1 = reinterpret_cast< wxValidator * >(argp1);
41371 {
41372 PyThreadState* __tstate = wxPyBeginAllowThreads();
41373 result = (bool)(arg1)->TransferFromWindow();
41374 wxPyEndAllowThreads(__tstate);
41375 if (PyErr_Occurred()) SWIG_fail;
41376 }
41377 {
41378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41379 }
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41387 PyObject *resultobj = 0;
41388 wxValidator *arg1 = (wxValidator *) 0 ;
41389 wxWindow *result = 0 ;
41390 void *argp1 = 0 ;
41391 int res1 = 0 ;
41392 PyObject *swig_obj[1] ;
41393
41394 if (!args) SWIG_fail;
41395 swig_obj[0] = args;
41396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41397 if (!SWIG_IsOK(res1)) {
41398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41399 }
41400 arg1 = reinterpret_cast< wxValidator * >(argp1);
41401 {
41402 PyThreadState* __tstate = wxPyBeginAllowThreads();
41403 result = (wxWindow *)(arg1)->GetWindow();
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 {
41408 resultobj = wxPyMake_wxObject(result, 0);
41409 }
41410 return resultobj;
41411 fail:
41412 return NULL;
41413 }
41414
41415
41416 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41417 PyObject *resultobj = 0;
41418 wxValidator *arg1 = (wxValidator *) 0 ;
41419 wxWindow *arg2 = (wxWindow *) 0 ;
41420 void *argp1 = 0 ;
41421 int res1 = 0 ;
41422 void *argp2 = 0 ;
41423 int res2 = 0 ;
41424 PyObject * obj0 = 0 ;
41425 PyObject * obj1 = 0 ;
41426 char * kwnames[] = {
41427 (char *) "self",(char *) "window", NULL
41428 };
41429
41430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41432 if (!SWIG_IsOK(res1)) {
41433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41434 }
41435 arg1 = reinterpret_cast< wxValidator * >(argp1);
41436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41437 if (!SWIG_IsOK(res2)) {
41438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41439 }
41440 arg2 = reinterpret_cast< wxWindow * >(argp2);
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 (arg1)->SetWindow(arg2);
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 resultobj = SWIG_Py_Void();
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41455 PyObject *resultobj = 0;
41456 bool result;
41457
41458 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41459 {
41460 PyThreadState* __tstate = wxPyBeginAllowThreads();
41461 result = (bool)wxValidator::IsSilent();
41462 wxPyEndAllowThreads(__tstate);
41463 if (PyErr_Occurred()) SWIG_fail;
41464 }
41465 {
41466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41467 }
41468 return resultobj;
41469 fail:
41470 return NULL;
41471 }
41472
41473
41474 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41475 PyObject *resultobj = 0;
41476 int arg1 = (int) true ;
41477 int val1 ;
41478 int ecode1 = 0 ;
41479 PyObject * obj0 = 0 ;
41480 char * kwnames[] = {
41481 (char *) "doIt", NULL
41482 };
41483
41484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41485 if (obj0) {
41486 ecode1 = SWIG_AsVal_int(obj0, &val1);
41487 if (!SWIG_IsOK(ecode1)) {
41488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41489 }
41490 arg1 = static_cast< int >(val1);
41491 }
41492 {
41493 PyThreadState* __tstate = wxPyBeginAllowThreads();
41494 wxValidator::SetBellOnError(arg1);
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 resultobj = SWIG_Py_Void();
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41506 PyObject *obj;
41507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41508 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41509 return SWIG_Py_Void();
41510 }
41511
41512 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41513 return SWIG_Python_InitShadowInstance(args);
41514 }
41515
41516 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41517 PyObject *resultobj = 0;
41518 wxPyValidator *result = 0 ;
41519
41520 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 result = (wxPyValidator *)new wxPyValidator();
41524 wxPyEndAllowThreads(__tstate);
41525 if (PyErr_Occurred()) SWIG_fail;
41526 }
41527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41528 return resultobj;
41529 fail:
41530 return NULL;
41531 }
41532
41533
41534 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41535 PyObject *resultobj = 0;
41536 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41537 PyObject *arg2 = (PyObject *) 0 ;
41538 PyObject *arg3 = (PyObject *) 0 ;
41539 int arg4 = (int) 1 ;
41540 void *argp1 = 0 ;
41541 int res1 = 0 ;
41542 int val4 ;
41543 int ecode4 = 0 ;
41544 PyObject * obj0 = 0 ;
41545 PyObject * obj1 = 0 ;
41546 PyObject * obj2 = 0 ;
41547 PyObject * obj3 = 0 ;
41548 char * kwnames[] = {
41549 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41550 };
41551
41552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41554 if (!SWIG_IsOK(res1)) {
41555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41556 }
41557 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41558 arg2 = obj1;
41559 arg3 = obj2;
41560 if (obj3) {
41561 ecode4 = SWIG_AsVal_int(obj3, &val4);
41562 if (!SWIG_IsOK(ecode4)) {
41563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41564 }
41565 arg4 = static_cast< int >(val4);
41566 }
41567 {
41568 PyThreadState* __tstate = wxPyBeginAllowThreads();
41569 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 resultobj = SWIG_Py_Void();
41574 return resultobj;
41575 fail:
41576 return NULL;
41577 }
41578
41579
41580 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41581 PyObject *obj;
41582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41583 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41584 return SWIG_Py_Void();
41585 }
41586
41587 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41588 return SWIG_Python_InitShadowInstance(args);
41589 }
41590
41591 SWIGINTERN int DefaultValidator_set(PyObject *) {
41592 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41593 return 1;
41594 }
41595
41596
41597 SWIGINTERN PyObject *DefaultValidator_get(void) {
41598 PyObject *pyobj = 0;
41599
41600 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41601 return pyobj;
41602 }
41603
41604
41605 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41606 PyObject *resultobj = 0;
41607 wxString const &arg1_defvalue = wxPyEmptyString ;
41608 wxString *arg1 = (wxString *) &arg1_defvalue ;
41609 long arg2 = (long) 0 ;
41610 wxMenu *result = 0 ;
41611 bool temp1 = false ;
41612 long val2 ;
41613 int ecode2 = 0 ;
41614 PyObject * obj0 = 0 ;
41615 PyObject * obj1 = 0 ;
41616 char * kwnames[] = {
41617 (char *) "title",(char *) "style", NULL
41618 };
41619
41620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41621 if (obj0) {
41622 {
41623 arg1 = wxString_in_helper(obj0);
41624 if (arg1 == NULL) SWIG_fail;
41625 temp1 = true;
41626 }
41627 }
41628 if (obj1) {
41629 ecode2 = SWIG_AsVal_long(obj1, &val2);
41630 if (!SWIG_IsOK(ecode2)) {
41631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41632 }
41633 arg2 = static_cast< long >(val2);
41634 }
41635 {
41636 if (!wxPyCheckForApp()) SWIG_fail;
41637 PyThreadState* __tstate = wxPyBeginAllowThreads();
41638 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41639 wxPyEndAllowThreads(__tstate);
41640 if (PyErr_Occurred()) SWIG_fail;
41641 }
41642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41643 {
41644 if (temp1)
41645 delete arg1;
41646 }
41647 return resultobj;
41648 fail:
41649 {
41650 if (temp1)
41651 delete arg1;
41652 }
41653 return NULL;
41654 }
41655
41656
41657 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41658 PyObject *resultobj = 0;
41659 wxMenu *arg1 = (wxMenu *) 0 ;
41660 int arg2 ;
41661 wxString const &arg3_defvalue = wxPyEmptyString ;
41662 wxString *arg3 = (wxString *) &arg3_defvalue ;
41663 wxString const &arg4_defvalue = wxPyEmptyString ;
41664 wxString *arg4 = (wxString *) &arg4_defvalue ;
41665 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41666 wxMenuItem *result = 0 ;
41667 void *argp1 = 0 ;
41668 int res1 = 0 ;
41669 int val2 ;
41670 int ecode2 = 0 ;
41671 bool temp3 = false ;
41672 bool temp4 = false ;
41673 int val5 ;
41674 int ecode5 = 0 ;
41675 PyObject * obj0 = 0 ;
41676 PyObject * obj1 = 0 ;
41677 PyObject * obj2 = 0 ;
41678 PyObject * obj3 = 0 ;
41679 PyObject * obj4 = 0 ;
41680 char * kwnames[] = {
41681 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41682 };
41683
41684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41686 if (!SWIG_IsOK(res1)) {
41687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41688 }
41689 arg1 = reinterpret_cast< wxMenu * >(argp1);
41690 ecode2 = SWIG_AsVal_int(obj1, &val2);
41691 if (!SWIG_IsOK(ecode2)) {
41692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41693 }
41694 arg2 = static_cast< int >(val2);
41695 if (obj2) {
41696 {
41697 arg3 = wxString_in_helper(obj2);
41698 if (arg3 == NULL) SWIG_fail;
41699 temp3 = true;
41700 }
41701 }
41702 if (obj3) {
41703 {
41704 arg4 = wxString_in_helper(obj3);
41705 if (arg4 == NULL) SWIG_fail;
41706 temp4 = true;
41707 }
41708 }
41709 if (obj4) {
41710 ecode5 = SWIG_AsVal_int(obj4, &val5);
41711 if (!SWIG_IsOK(ecode5)) {
41712 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41713 }
41714 arg5 = static_cast< wxItemKind >(val5);
41715 }
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41719 wxPyEndAllowThreads(__tstate);
41720 if (PyErr_Occurred()) SWIG_fail;
41721 }
41722 {
41723 resultobj = wxPyMake_wxObject(result, (bool)0);
41724 }
41725 {
41726 if (temp3)
41727 delete arg3;
41728 }
41729 {
41730 if (temp4)
41731 delete arg4;
41732 }
41733 return resultobj;
41734 fail:
41735 {
41736 if (temp3)
41737 delete arg3;
41738 }
41739 {
41740 if (temp4)
41741 delete arg4;
41742 }
41743 return NULL;
41744 }
41745
41746
41747 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41748 PyObject *resultobj = 0;
41749 wxMenu *arg1 = (wxMenu *) 0 ;
41750 wxMenuItem *result = 0 ;
41751 void *argp1 = 0 ;
41752 int res1 = 0 ;
41753 PyObject *swig_obj[1] ;
41754
41755 if (!args) SWIG_fail;
41756 swig_obj[0] = args;
41757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41758 if (!SWIG_IsOK(res1)) {
41759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41760 }
41761 arg1 = reinterpret_cast< wxMenu * >(argp1);
41762 {
41763 PyThreadState* __tstate = wxPyBeginAllowThreads();
41764 result = (wxMenuItem *)(arg1)->AppendSeparator();
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 {
41769 resultobj = wxPyMake_wxObject(result, (bool)0);
41770 }
41771 return resultobj;
41772 fail:
41773 return NULL;
41774 }
41775
41776
41777 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41778 PyObject *resultobj = 0;
41779 wxMenu *arg1 = (wxMenu *) 0 ;
41780 int arg2 ;
41781 wxString *arg3 = 0 ;
41782 wxString const &arg4_defvalue = wxPyEmptyString ;
41783 wxString *arg4 = (wxString *) &arg4_defvalue ;
41784 wxMenuItem *result = 0 ;
41785 void *argp1 = 0 ;
41786 int res1 = 0 ;
41787 int val2 ;
41788 int ecode2 = 0 ;
41789 bool temp3 = false ;
41790 bool temp4 = false ;
41791 PyObject * obj0 = 0 ;
41792 PyObject * obj1 = 0 ;
41793 PyObject * obj2 = 0 ;
41794 PyObject * obj3 = 0 ;
41795 char * kwnames[] = {
41796 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41797 };
41798
41799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41801 if (!SWIG_IsOK(res1)) {
41802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41803 }
41804 arg1 = reinterpret_cast< wxMenu * >(argp1);
41805 ecode2 = SWIG_AsVal_int(obj1, &val2);
41806 if (!SWIG_IsOK(ecode2)) {
41807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41808 }
41809 arg2 = static_cast< int >(val2);
41810 {
41811 arg3 = wxString_in_helper(obj2);
41812 if (arg3 == NULL) SWIG_fail;
41813 temp3 = true;
41814 }
41815 if (obj3) {
41816 {
41817 arg4 = wxString_in_helper(obj3);
41818 if (arg4 == NULL) SWIG_fail;
41819 temp4 = true;
41820 }
41821 }
41822 {
41823 PyThreadState* __tstate = wxPyBeginAllowThreads();
41824 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41825 wxPyEndAllowThreads(__tstate);
41826 if (PyErr_Occurred()) SWIG_fail;
41827 }
41828 {
41829 resultobj = wxPyMake_wxObject(result, (bool)0);
41830 }
41831 {
41832 if (temp3)
41833 delete arg3;
41834 }
41835 {
41836 if (temp4)
41837 delete arg4;
41838 }
41839 return resultobj;
41840 fail:
41841 {
41842 if (temp3)
41843 delete arg3;
41844 }
41845 {
41846 if (temp4)
41847 delete arg4;
41848 }
41849 return NULL;
41850 }
41851
41852
41853 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41854 PyObject *resultobj = 0;
41855 wxMenu *arg1 = (wxMenu *) 0 ;
41856 int arg2 ;
41857 wxString *arg3 = 0 ;
41858 wxString const &arg4_defvalue = wxPyEmptyString ;
41859 wxString *arg4 = (wxString *) &arg4_defvalue ;
41860 wxMenuItem *result = 0 ;
41861 void *argp1 = 0 ;
41862 int res1 = 0 ;
41863 int val2 ;
41864 int ecode2 = 0 ;
41865 bool temp3 = false ;
41866 bool temp4 = false ;
41867 PyObject * obj0 = 0 ;
41868 PyObject * obj1 = 0 ;
41869 PyObject * obj2 = 0 ;
41870 PyObject * obj3 = 0 ;
41871 char * kwnames[] = {
41872 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41873 };
41874
41875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41877 if (!SWIG_IsOK(res1)) {
41878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41879 }
41880 arg1 = reinterpret_cast< wxMenu * >(argp1);
41881 ecode2 = SWIG_AsVal_int(obj1, &val2);
41882 if (!SWIG_IsOK(ecode2)) {
41883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41884 }
41885 arg2 = static_cast< int >(val2);
41886 {
41887 arg3 = wxString_in_helper(obj2);
41888 if (arg3 == NULL) SWIG_fail;
41889 temp3 = true;
41890 }
41891 if (obj3) {
41892 {
41893 arg4 = wxString_in_helper(obj3);
41894 if (arg4 == NULL) SWIG_fail;
41895 temp4 = true;
41896 }
41897 }
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 resultobj = wxPyMake_wxObject(result, (bool)0);
41906 }
41907 {
41908 if (temp3)
41909 delete arg3;
41910 }
41911 {
41912 if (temp4)
41913 delete arg4;
41914 }
41915 return resultobj;
41916 fail:
41917 {
41918 if (temp3)
41919 delete arg3;
41920 }
41921 {
41922 if (temp4)
41923 delete arg4;
41924 }
41925 return NULL;
41926 }
41927
41928
41929 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41930 PyObject *resultobj = 0;
41931 wxMenu *arg1 = (wxMenu *) 0 ;
41932 int arg2 ;
41933 wxString *arg3 = 0 ;
41934 wxMenu *arg4 = (wxMenu *) 0 ;
41935 wxString const &arg5_defvalue = wxPyEmptyString ;
41936 wxString *arg5 = (wxString *) &arg5_defvalue ;
41937 wxMenuItem *result = 0 ;
41938 void *argp1 = 0 ;
41939 int res1 = 0 ;
41940 int val2 ;
41941 int ecode2 = 0 ;
41942 bool temp3 = false ;
41943 void *argp4 = 0 ;
41944 int res4 = 0 ;
41945 bool temp5 = false ;
41946 PyObject * obj0 = 0 ;
41947 PyObject * obj1 = 0 ;
41948 PyObject * obj2 = 0 ;
41949 PyObject * obj3 = 0 ;
41950 PyObject * obj4 = 0 ;
41951 char * kwnames[] = {
41952 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41953 };
41954
41955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41957 if (!SWIG_IsOK(res1)) {
41958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41959 }
41960 arg1 = reinterpret_cast< wxMenu * >(argp1);
41961 ecode2 = SWIG_AsVal_int(obj1, &val2);
41962 if (!SWIG_IsOK(ecode2)) {
41963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41964 }
41965 arg2 = static_cast< int >(val2);
41966 {
41967 arg3 = wxString_in_helper(obj2);
41968 if (arg3 == NULL) SWIG_fail;
41969 temp3 = true;
41970 }
41971 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41972 if (!SWIG_IsOK(res4)) {
41973 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41974 }
41975 arg4 = reinterpret_cast< wxMenu * >(argp4);
41976 if (obj4) {
41977 {
41978 arg5 = wxString_in_helper(obj4);
41979 if (arg5 == NULL) SWIG_fail;
41980 temp5 = true;
41981 }
41982 }
41983 {
41984 PyThreadState* __tstate = wxPyBeginAllowThreads();
41985 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
41986 wxPyEndAllowThreads(__tstate);
41987 if (PyErr_Occurred()) SWIG_fail;
41988 }
41989 {
41990 resultobj = wxPyMake_wxObject(result, (bool)0);
41991 }
41992 {
41993 if (temp3)
41994 delete arg3;
41995 }
41996 {
41997 if (temp5)
41998 delete arg5;
41999 }
42000 return resultobj;
42001 fail:
42002 {
42003 if (temp3)
42004 delete arg3;
42005 }
42006 {
42007 if (temp5)
42008 delete arg5;
42009 }
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj = 0;
42016 wxMenu *arg1 = (wxMenu *) 0 ;
42017 wxMenu *arg2 = (wxMenu *) 0 ;
42018 wxString *arg3 = 0 ;
42019 wxString const &arg4_defvalue = wxPyEmptyString ;
42020 wxString *arg4 = (wxString *) &arg4_defvalue ;
42021 wxMenuItem *result = 0 ;
42022 void *argp1 = 0 ;
42023 int res1 = 0 ;
42024 void *argp2 = 0 ;
42025 int res2 = 0 ;
42026 bool temp3 = false ;
42027 bool temp4 = false ;
42028 PyObject * obj0 = 0 ;
42029 PyObject * obj1 = 0 ;
42030 PyObject * obj2 = 0 ;
42031 PyObject * obj3 = 0 ;
42032 char * kwnames[] = {
42033 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42034 };
42035
42036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42038 if (!SWIG_IsOK(res1)) {
42039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42040 }
42041 arg1 = reinterpret_cast< wxMenu * >(argp1);
42042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42043 if (!SWIG_IsOK(res2)) {
42044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42045 }
42046 arg2 = reinterpret_cast< wxMenu * >(argp2);
42047 {
42048 arg3 = wxString_in_helper(obj2);
42049 if (arg3 == NULL) SWIG_fail;
42050 temp3 = true;
42051 }
42052 if (obj3) {
42053 {
42054 arg4 = wxString_in_helper(obj3);
42055 if (arg4 == NULL) SWIG_fail;
42056 temp4 = true;
42057 }
42058 }
42059 {
42060 PyThreadState* __tstate = wxPyBeginAllowThreads();
42061 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42062 wxPyEndAllowThreads(__tstate);
42063 if (PyErr_Occurred()) SWIG_fail;
42064 }
42065 {
42066 resultobj = wxPyMake_wxObject(result, (bool)0);
42067 }
42068 {
42069 if (temp3)
42070 delete arg3;
42071 }
42072 {
42073 if (temp4)
42074 delete arg4;
42075 }
42076 return resultobj;
42077 fail:
42078 {
42079 if (temp3)
42080 delete arg3;
42081 }
42082 {
42083 if (temp4)
42084 delete arg4;
42085 }
42086 return NULL;
42087 }
42088
42089
42090 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42091 PyObject *resultobj = 0;
42092 wxMenu *arg1 = (wxMenu *) 0 ;
42093 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42094 wxMenuItem *result = 0 ;
42095 void *argp1 = 0 ;
42096 int res1 = 0 ;
42097 int res2 = 0 ;
42098 PyObject * obj0 = 0 ;
42099 PyObject * obj1 = 0 ;
42100 char * kwnames[] = {
42101 (char *) "self",(char *) "item", NULL
42102 };
42103
42104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42106 if (!SWIG_IsOK(res1)) {
42107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42108 }
42109 arg1 = reinterpret_cast< wxMenu * >(argp1);
42110 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42111 if (!SWIG_IsOK(res2)) {
42112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42113 }
42114 {
42115 PyThreadState* __tstate = wxPyBeginAllowThreads();
42116 result = (wxMenuItem *)(arg1)->Append(arg2);
42117 wxPyEndAllowThreads(__tstate);
42118 if (PyErr_Occurred()) SWIG_fail;
42119 }
42120 {
42121 resultobj = wxPyMake_wxObject(result, (bool)0);
42122 }
42123 return resultobj;
42124 fail:
42125 return NULL;
42126 }
42127
42128
42129 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42130 PyObject *resultobj = 0;
42131 wxMenu *arg1 = (wxMenu *) 0 ;
42132 size_t arg2 ;
42133 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42134 wxMenuItem *result = 0 ;
42135 void *argp1 = 0 ;
42136 int res1 = 0 ;
42137 size_t val2 ;
42138 int ecode2 = 0 ;
42139 int res3 = 0 ;
42140 PyObject * obj0 = 0 ;
42141 PyObject * obj1 = 0 ;
42142 PyObject * obj2 = 0 ;
42143 char * kwnames[] = {
42144 (char *) "self",(char *) "pos",(char *) "item", NULL
42145 };
42146
42147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42149 if (!SWIG_IsOK(res1)) {
42150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42151 }
42152 arg1 = reinterpret_cast< wxMenu * >(argp1);
42153 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42154 if (!SWIG_IsOK(ecode2)) {
42155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42156 }
42157 arg2 = static_cast< size_t >(val2);
42158 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42159 if (!SWIG_IsOK(res3)) {
42160 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42161 }
42162 {
42163 PyThreadState* __tstate = wxPyBeginAllowThreads();
42164 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42165 wxPyEndAllowThreads(__tstate);
42166 if (PyErr_Occurred()) SWIG_fail;
42167 }
42168 {
42169 resultobj = wxPyMake_wxObject(result, (bool)0);
42170 }
42171 return resultobj;
42172 fail:
42173 return NULL;
42174 }
42175
42176
42177 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42178 PyObject *resultobj = 0;
42179 wxMenu *arg1 = (wxMenu *) 0 ;
42180 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42181 wxMenuItem *result = 0 ;
42182 void *argp1 = 0 ;
42183 int res1 = 0 ;
42184 int res2 = 0 ;
42185 PyObject * obj0 = 0 ;
42186 PyObject * obj1 = 0 ;
42187 char * kwnames[] = {
42188 (char *) "self",(char *) "item", NULL
42189 };
42190
42191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42193 if (!SWIG_IsOK(res1)) {
42194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42195 }
42196 arg1 = reinterpret_cast< wxMenu * >(argp1);
42197 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42198 if (!SWIG_IsOK(res2)) {
42199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42200 }
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42204 wxPyEndAllowThreads(__tstate);
42205 if (PyErr_Occurred()) SWIG_fail;
42206 }
42207 {
42208 resultobj = wxPyMake_wxObject(result, (bool)0);
42209 }
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42217 PyObject *resultobj = 0;
42218 wxMenu *arg1 = (wxMenu *) 0 ;
42219 void *argp1 = 0 ;
42220 int res1 = 0 ;
42221 PyObject *swig_obj[1] ;
42222
42223 if (!args) SWIG_fail;
42224 swig_obj[0] = args;
42225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42226 if (!SWIG_IsOK(res1)) {
42227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42228 }
42229 arg1 = reinterpret_cast< wxMenu * >(argp1);
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 (arg1)->Break();
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 resultobj = SWIG_Py_Void();
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42244 PyObject *resultobj = 0;
42245 wxMenu *arg1 = (wxMenu *) 0 ;
42246 size_t arg2 ;
42247 int arg3 ;
42248 wxString const &arg4_defvalue = wxPyEmptyString ;
42249 wxString *arg4 = (wxString *) &arg4_defvalue ;
42250 wxString const &arg5_defvalue = wxPyEmptyString ;
42251 wxString *arg5 = (wxString *) &arg5_defvalue ;
42252 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42253 wxMenuItem *result = 0 ;
42254 void *argp1 = 0 ;
42255 int res1 = 0 ;
42256 size_t val2 ;
42257 int ecode2 = 0 ;
42258 int val3 ;
42259 int ecode3 = 0 ;
42260 bool temp4 = false ;
42261 bool temp5 = false ;
42262 int val6 ;
42263 int ecode6 = 0 ;
42264 PyObject * obj0 = 0 ;
42265 PyObject * obj1 = 0 ;
42266 PyObject * obj2 = 0 ;
42267 PyObject * obj3 = 0 ;
42268 PyObject * obj4 = 0 ;
42269 PyObject * obj5 = 0 ;
42270 char * kwnames[] = {
42271 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42272 };
42273
42274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42276 if (!SWIG_IsOK(res1)) {
42277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42278 }
42279 arg1 = reinterpret_cast< wxMenu * >(argp1);
42280 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42281 if (!SWIG_IsOK(ecode2)) {
42282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42283 }
42284 arg2 = static_cast< size_t >(val2);
42285 ecode3 = SWIG_AsVal_int(obj2, &val3);
42286 if (!SWIG_IsOK(ecode3)) {
42287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42288 }
42289 arg3 = static_cast< int >(val3);
42290 if (obj3) {
42291 {
42292 arg4 = wxString_in_helper(obj3);
42293 if (arg4 == NULL) SWIG_fail;
42294 temp4 = true;
42295 }
42296 }
42297 if (obj4) {
42298 {
42299 arg5 = wxString_in_helper(obj4);
42300 if (arg5 == NULL) SWIG_fail;
42301 temp5 = true;
42302 }
42303 }
42304 if (obj5) {
42305 ecode6 = SWIG_AsVal_int(obj5, &val6);
42306 if (!SWIG_IsOK(ecode6)) {
42307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42308 }
42309 arg6 = static_cast< wxItemKind >(val6);
42310 }
42311 {
42312 PyThreadState* __tstate = wxPyBeginAllowThreads();
42313 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42314 wxPyEndAllowThreads(__tstate);
42315 if (PyErr_Occurred()) SWIG_fail;
42316 }
42317 {
42318 resultobj = wxPyMake_wxObject(result, (bool)0);
42319 }
42320 {
42321 if (temp4)
42322 delete arg4;
42323 }
42324 {
42325 if (temp5)
42326 delete arg5;
42327 }
42328 return resultobj;
42329 fail:
42330 {
42331 if (temp4)
42332 delete arg4;
42333 }
42334 {
42335 if (temp5)
42336 delete arg5;
42337 }
42338 return NULL;
42339 }
42340
42341
42342 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42343 PyObject *resultobj = 0;
42344 wxMenu *arg1 = (wxMenu *) 0 ;
42345 size_t arg2 ;
42346 wxMenuItem *result = 0 ;
42347 void *argp1 = 0 ;
42348 int res1 = 0 ;
42349 size_t val2 ;
42350 int ecode2 = 0 ;
42351 PyObject * obj0 = 0 ;
42352 PyObject * obj1 = 0 ;
42353 char * kwnames[] = {
42354 (char *) "self",(char *) "pos", NULL
42355 };
42356
42357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42359 if (!SWIG_IsOK(res1)) {
42360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42361 }
42362 arg1 = reinterpret_cast< wxMenu * >(argp1);
42363 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42364 if (!SWIG_IsOK(ecode2)) {
42365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42366 }
42367 arg2 = static_cast< size_t >(val2);
42368 {
42369 PyThreadState* __tstate = wxPyBeginAllowThreads();
42370 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42371 wxPyEndAllowThreads(__tstate);
42372 if (PyErr_Occurred()) SWIG_fail;
42373 }
42374 {
42375 resultobj = wxPyMake_wxObject(result, (bool)0);
42376 }
42377 return resultobj;
42378 fail:
42379 return NULL;
42380 }
42381
42382
42383 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42384 PyObject *resultobj = 0;
42385 wxMenu *arg1 = (wxMenu *) 0 ;
42386 size_t arg2 ;
42387 int arg3 ;
42388 wxString *arg4 = 0 ;
42389 wxString const &arg5_defvalue = wxPyEmptyString ;
42390 wxString *arg5 = (wxString *) &arg5_defvalue ;
42391 wxMenuItem *result = 0 ;
42392 void *argp1 = 0 ;
42393 int res1 = 0 ;
42394 size_t val2 ;
42395 int ecode2 = 0 ;
42396 int val3 ;
42397 int ecode3 = 0 ;
42398 bool temp4 = false ;
42399 bool temp5 = false ;
42400 PyObject * obj0 = 0 ;
42401 PyObject * obj1 = 0 ;
42402 PyObject * obj2 = 0 ;
42403 PyObject * obj3 = 0 ;
42404 PyObject * obj4 = 0 ;
42405 char * kwnames[] = {
42406 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42407 };
42408
42409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42411 if (!SWIG_IsOK(res1)) {
42412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42413 }
42414 arg1 = reinterpret_cast< wxMenu * >(argp1);
42415 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42416 if (!SWIG_IsOK(ecode2)) {
42417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42418 }
42419 arg2 = static_cast< size_t >(val2);
42420 ecode3 = SWIG_AsVal_int(obj2, &val3);
42421 if (!SWIG_IsOK(ecode3)) {
42422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42423 }
42424 arg3 = static_cast< int >(val3);
42425 {
42426 arg4 = wxString_in_helper(obj3);
42427 if (arg4 == NULL) SWIG_fail;
42428 temp4 = true;
42429 }
42430 if (obj4) {
42431 {
42432 arg5 = wxString_in_helper(obj4);
42433 if (arg5 == NULL) SWIG_fail;
42434 temp5 = true;
42435 }
42436 }
42437 {
42438 PyThreadState* __tstate = wxPyBeginAllowThreads();
42439 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42440 wxPyEndAllowThreads(__tstate);
42441 if (PyErr_Occurred()) SWIG_fail;
42442 }
42443 {
42444 resultobj = wxPyMake_wxObject(result, (bool)0);
42445 }
42446 {
42447 if (temp4)
42448 delete arg4;
42449 }
42450 {
42451 if (temp5)
42452 delete arg5;
42453 }
42454 return resultobj;
42455 fail:
42456 {
42457 if (temp4)
42458 delete arg4;
42459 }
42460 {
42461 if (temp5)
42462 delete arg5;
42463 }
42464 return NULL;
42465 }
42466
42467
42468 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42469 PyObject *resultobj = 0;
42470 wxMenu *arg1 = (wxMenu *) 0 ;
42471 size_t arg2 ;
42472 int arg3 ;
42473 wxString *arg4 = 0 ;
42474 wxString const &arg5_defvalue = wxPyEmptyString ;
42475 wxString *arg5 = (wxString *) &arg5_defvalue ;
42476 wxMenuItem *result = 0 ;
42477 void *argp1 = 0 ;
42478 int res1 = 0 ;
42479 size_t val2 ;
42480 int ecode2 = 0 ;
42481 int val3 ;
42482 int ecode3 = 0 ;
42483 bool temp4 = false ;
42484 bool temp5 = false ;
42485 PyObject * obj0 = 0 ;
42486 PyObject * obj1 = 0 ;
42487 PyObject * obj2 = 0 ;
42488 PyObject * obj3 = 0 ;
42489 PyObject * obj4 = 0 ;
42490 char * kwnames[] = {
42491 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42492 };
42493
42494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42496 if (!SWIG_IsOK(res1)) {
42497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42498 }
42499 arg1 = reinterpret_cast< wxMenu * >(argp1);
42500 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42501 if (!SWIG_IsOK(ecode2)) {
42502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42503 }
42504 arg2 = static_cast< size_t >(val2);
42505 ecode3 = SWIG_AsVal_int(obj2, &val3);
42506 if (!SWIG_IsOK(ecode3)) {
42507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42508 }
42509 arg3 = static_cast< int >(val3);
42510 {
42511 arg4 = wxString_in_helper(obj3);
42512 if (arg4 == NULL) SWIG_fail;
42513 temp4 = true;
42514 }
42515 if (obj4) {
42516 {
42517 arg5 = wxString_in_helper(obj4);
42518 if (arg5 == NULL) SWIG_fail;
42519 temp5 = true;
42520 }
42521 }
42522 {
42523 PyThreadState* __tstate = wxPyBeginAllowThreads();
42524 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42525 wxPyEndAllowThreads(__tstate);
42526 if (PyErr_Occurred()) SWIG_fail;
42527 }
42528 {
42529 resultobj = wxPyMake_wxObject(result, (bool)0);
42530 }
42531 {
42532 if (temp4)
42533 delete arg4;
42534 }
42535 {
42536 if (temp5)
42537 delete arg5;
42538 }
42539 return resultobj;
42540 fail:
42541 {
42542 if (temp4)
42543 delete arg4;
42544 }
42545 {
42546 if (temp5)
42547 delete arg5;
42548 }
42549 return NULL;
42550 }
42551
42552
42553 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42554 PyObject *resultobj = 0;
42555 wxMenu *arg1 = (wxMenu *) 0 ;
42556 size_t arg2 ;
42557 int arg3 ;
42558 wxString *arg4 = 0 ;
42559 wxMenu *arg5 = (wxMenu *) 0 ;
42560 wxString const &arg6_defvalue = wxPyEmptyString ;
42561 wxString *arg6 = (wxString *) &arg6_defvalue ;
42562 wxMenuItem *result = 0 ;
42563 void *argp1 = 0 ;
42564 int res1 = 0 ;
42565 size_t val2 ;
42566 int ecode2 = 0 ;
42567 int val3 ;
42568 int ecode3 = 0 ;
42569 bool temp4 = false ;
42570 void *argp5 = 0 ;
42571 int res5 = 0 ;
42572 bool temp6 = false ;
42573 PyObject * obj0 = 0 ;
42574 PyObject * obj1 = 0 ;
42575 PyObject * obj2 = 0 ;
42576 PyObject * obj3 = 0 ;
42577 PyObject * obj4 = 0 ;
42578 PyObject * obj5 = 0 ;
42579 char * kwnames[] = {
42580 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42581 };
42582
42583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42585 if (!SWIG_IsOK(res1)) {
42586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42587 }
42588 arg1 = reinterpret_cast< wxMenu * >(argp1);
42589 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42590 if (!SWIG_IsOK(ecode2)) {
42591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42592 }
42593 arg2 = static_cast< size_t >(val2);
42594 ecode3 = SWIG_AsVal_int(obj2, &val3);
42595 if (!SWIG_IsOK(ecode3)) {
42596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42597 }
42598 arg3 = static_cast< int >(val3);
42599 {
42600 arg4 = wxString_in_helper(obj3);
42601 if (arg4 == NULL) SWIG_fail;
42602 temp4 = true;
42603 }
42604 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42605 if (!SWIG_IsOK(res5)) {
42606 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42607 }
42608 arg5 = reinterpret_cast< wxMenu * >(argp5);
42609 if (obj5) {
42610 {
42611 arg6 = wxString_in_helper(obj5);
42612 if (arg6 == NULL) SWIG_fail;
42613 temp6 = true;
42614 }
42615 }
42616 {
42617 PyThreadState* __tstate = wxPyBeginAllowThreads();
42618 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 {
42623 resultobj = wxPyMake_wxObject(result, (bool)0);
42624 }
42625 {
42626 if (temp4)
42627 delete arg4;
42628 }
42629 {
42630 if (temp6)
42631 delete arg6;
42632 }
42633 return resultobj;
42634 fail:
42635 {
42636 if (temp4)
42637 delete arg4;
42638 }
42639 {
42640 if (temp6)
42641 delete arg6;
42642 }
42643 return NULL;
42644 }
42645
42646
42647 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42648 PyObject *resultobj = 0;
42649 wxMenu *arg1 = (wxMenu *) 0 ;
42650 int arg2 ;
42651 wxString const &arg3_defvalue = wxPyEmptyString ;
42652 wxString *arg3 = (wxString *) &arg3_defvalue ;
42653 wxString const &arg4_defvalue = wxPyEmptyString ;
42654 wxString *arg4 = (wxString *) &arg4_defvalue ;
42655 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42656 wxMenuItem *result = 0 ;
42657 void *argp1 = 0 ;
42658 int res1 = 0 ;
42659 int val2 ;
42660 int ecode2 = 0 ;
42661 bool temp3 = false ;
42662 bool temp4 = false ;
42663 int val5 ;
42664 int ecode5 = 0 ;
42665 PyObject * obj0 = 0 ;
42666 PyObject * obj1 = 0 ;
42667 PyObject * obj2 = 0 ;
42668 PyObject * obj3 = 0 ;
42669 PyObject * obj4 = 0 ;
42670 char * kwnames[] = {
42671 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42672 };
42673
42674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42676 if (!SWIG_IsOK(res1)) {
42677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42678 }
42679 arg1 = reinterpret_cast< wxMenu * >(argp1);
42680 ecode2 = SWIG_AsVal_int(obj1, &val2);
42681 if (!SWIG_IsOK(ecode2)) {
42682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42683 }
42684 arg2 = static_cast< int >(val2);
42685 if (obj2) {
42686 {
42687 arg3 = wxString_in_helper(obj2);
42688 if (arg3 == NULL) SWIG_fail;
42689 temp3 = true;
42690 }
42691 }
42692 if (obj3) {
42693 {
42694 arg4 = wxString_in_helper(obj3);
42695 if (arg4 == NULL) SWIG_fail;
42696 temp4 = true;
42697 }
42698 }
42699 if (obj4) {
42700 ecode5 = SWIG_AsVal_int(obj4, &val5);
42701 if (!SWIG_IsOK(ecode5)) {
42702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42703 }
42704 arg5 = static_cast< wxItemKind >(val5);
42705 }
42706 {
42707 PyThreadState* __tstate = wxPyBeginAllowThreads();
42708 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 {
42713 resultobj = wxPyMake_wxObject(result, (bool)0);
42714 }
42715 {
42716 if (temp3)
42717 delete arg3;
42718 }
42719 {
42720 if (temp4)
42721 delete arg4;
42722 }
42723 return resultobj;
42724 fail:
42725 {
42726 if (temp3)
42727 delete arg3;
42728 }
42729 {
42730 if (temp4)
42731 delete arg4;
42732 }
42733 return NULL;
42734 }
42735
42736
42737 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42738 PyObject *resultobj = 0;
42739 wxMenu *arg1 = (wxMenu *) 0 ;
42740 wxMenuItem *result = 0 ;
42741 void *argp1 = 0 ;
42742 int res1 = 0 ;
42743 PyObject *swig_obj[1] ;
42744
42745 if (!args) SWIG_fail;
42746 swig_obj[0] = args;
42747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42748 if (!SWIG_IsOK(res1)) {
42749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42750 }
42751 arg1 = reinterpret_cast< wxMenu * >(argp1);
42752 {
42753 PyThreadState* __tstate = wxPyBeginAllowThreads();
42754 result = (wxMenuItem *)(arg1)->PrependSeparator();
42755 wxPyEndAllowThreads(__tstate);
42756 if (PyErr_Occurred()) SWIG_fail;
42757 }
42758 {
42759 resultobj = wxPyMake_wxObject(result, (bool)0);
42760 }
42761 return resultobj;
42762 fail:
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42768 PyObject *resultobj = 0;
42769 wxMenu *arg1 = (wxMenu *) 0 ;
42770 int arg2 ;
42771 wxString *arg3 = 0 ;
42772 wxString const &arg4_defvalue = wxPyEmptyString ;
42773 wxString *arg4 = (wxString *) &arg4_defvalue ;
42774 wxMenuItem *result = 0 ;
42775 void *argp1 = 0 ;
42776 int res1 = 0 ;
42777 int val2 ;
42778 int ecode2 = 0 ;
42779 bool temp3 = false ;
42780 bool temp4 = false ;
42781 PyObject * obj0 = 0 ;
42782 PyObject * obj1 = 0 ;
42783 PyObject * obj2 = 0 ;
42784 PyObject * obj3 = 0 ;
42785 char * kwnames[] = {
42786 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42787 };
42788
42789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42791 if (!SWIG_IsOK(res1)) {
42792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42793 }
42794 arg1 = reinterpret_cast< wxMenu * >(argp1);
42795 ecode2 = SWIG_AsVal_int(obj1, &val2);
42796 if (!SWIG_IsOK(ecode2)) {
42797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42798 }
42799 arg2 = static_cast< int >(val2);
42800 {
42801 arg3 = wxString_in_helper(obj2);
42802 if (arg3 == NULL) SWIG_fail;
42803 temp3 = true;
42804 }
42805 if (obj3) {
42806 {
42807 arg4 = wxString_in_helper(obj3);
42808 if (arg4 == NULL) SWIG_fail;
42809 temp4 = true;
42810 }
42811 }
42812 {
42813 PyThreadState* __tstate = wxPyBeginAllowThreads();
42814 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 {
42819 resultobj = wxPyMake_wxObject(result, (bool)0);
42820 }
42821 {
42822 if (temp3)
42823 delete arg3;
42824 }
42825 {
42826 if (temp4)
42827 delete arg4;
42828 }
42829 return resultobj;
42830 fail:
42831 {
42832 if (temp3)
42833 delete arg3;
42834 }
42835 {
42836 if (temp4)
42837 delete arg4;
42838 }
42839 return NULL;
42840 }
42841
42842
42843 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42844 PyObject *resultobj = 0;
42845 wxMenu *arg1 = (wxMenu *) 0 ;
42846 int arg2 ;
42847 wxString *arg3 = 0 ;
42848 wxString const &arg4_defvalue = wxPyEmptyString ;
42849 wxString *arg4 = (wxString *) &arg4_defvalue ;
42850 wxMenuItem *result = 0 ;
42851 void *argp1 = 0 ;
42852 int res1 = 0 ;
42853 int val2 ;
42854 int ecode2 = 0 ;
42855 bool temp3 = false ;
42856 bool temp4 = false ;
42857 PyObject * obj0 = 0 ;
42858 PyObject * obj1 = 0 ;
42859 PyObject * obj2 = 0 ;
42860 PyObject * obj3 = 0 ;
42861 char * kwnames[] = {
42862 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42863 };
42864
42865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42867 if (!SWIG_IsOK(res1)) {
42868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42869 }
42870 arg1 = reinterpret_cast< wxMenu * >(argp1);
42871 ecode2 = SWIG_AsVal_int(obj1, &val2);
42872 if (!SWIG_IsOK(ecode2)) {
42873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42874 }
42875 arg2 = static_cast< int >(val2);
42876 {
42877 arg3 = wxString_in_helper(obj2);
42878 if (arg3 == NULL) SWIG_fail;
42879 temp3 = true;
42880 }
42881 if (obj3) {
42882 {
42883 arg4 = wxString_in_helper(obj3);
42884 if (arg4 == NULL) SWIG_fail;
42885 temp4 = true;
42886 }
42887 }
42888 {
42889 PyThreadState* __tstate = wxPyBeginAllowThreads();
42890 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42891 wxPyEndAllowThreads(__tstate);
42892 if (PyErr_Occurred()) SWIG_fail;
42893 }
42894 {
42895 resultobj = wxPyMake_wxObject(result, (bool)0);
42896 }
42897 {
42898 if (temp3)
42899 delete arg3;
42900 }
42901 {
42902 if (temp4)
42903 delete arg4;
42904 }
42905 return resultobj;
42906 fail:
42907 {
42908 if (temp3)
42909 delete arg3;
42910 }
42911 {
42912 if (temp4)
42913 delete arg4;
42914 }
42915 return NULL;
42916 }
42917
42918
42919 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42920 PyObject *resultobj = 0;
42921 wxMenu *arg1 = (wxMenu *) 0 ;
42922 int arg2 ;
42923 wxString *arg3 = 0 ;
42924 wxMenu *arg4 = (wxMenu *) 0 ;
42925 wxString const &arg5_defvalue = wxPyEmptyString ;
42926 wxString *arg5 = (wxString *) &arg5_defvalue ;
42927 wxMenuItem *result = 0 ;
42928 void *argp1 = 0 ;
42929 int res1 = 0 ;
42930 int val2 ;
42931 int ecode2 = 0 ;
42932 bool temp3 = false ;
42933 void *argp4 = 0 ;
42934 int res4 = 0 ;
42935 bool temp5 = false ;
42936 PyObject * obj0 = 0 ;
42937 PyObject * obj1 = 0 ;
42938 PyObject * obj2 = 0 ;
42939 PyObject * obj3 = 0 ;
42940 PyObject * obj4 = 0 ;
42941 char * kwnames[] = {
42942 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42943 };
42944
42945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42947 if (!SWIG_IsOK(res1)) {
42948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42949 }
42950 arg1 = reinterpret_cast< wxMenu * >(argp1);
42951 ecode2 = SWIG_AsVal_int(obj1, &val2);
42952 if (!SWIG_IsOK(ecode2)) {
42953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42954 }
42955 arg2 = static_cast< int >(val2);
42956 {
42957 arg3 = wxString_in_helper(obj2);
42958 if (arg3 == NULL) SWIG_fail;
42959 temp3 = true;
42960 }
42961 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42962 if (!SWIG_IsOK(res4)) {
42963 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42964 }
42965 arg4 = reinterpret_cast< wxMenu * >(argp4);
42966 if (obj4) {
42967 {
42968 arg5 = wxString_in_helper(obj4);
42969 if (arg5 == NULL) SWIG_fail;
42970 temp5 = true;
42971 }
42972 }
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 {
42980 resultobj = wxPyMake_wxObject(result, (bool)0);
42981 }
42982 {
42983 if (temp3)
42984 delete arg3;
42985 }
42986 {
42987 if (temp5)
42988 delete arg5;
42989 }
42990 return resultobj;
42991 fail:
42992 {
42993 if (temp3)
42994 delete arg3;
42995 }
42996 {
42997 if (temp5)
42998 delete arg5;
42999 }
43000 return NULL;
43001 }
43002
43003
43004 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43005 PyObject *resultobj = 0;
43006 wxMenu *arg1 = (wxMenu *) 0 ;
43007 int arg2 ;
43008 wxMenuItem *result = 0 ;
43009 void *argp1 = 0 ;
43010 int res1 = 0 ;
43011 int val2 ;
43012 int ecode2 = 0 ;
43013 PyObject * obj0 = 0 ;
43014 PyObject * obj1 = 0 ;
43015 char * kwnames[] = {
43016 (char *) "self",(char *) "id", NULL
43017 };
43018
43019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43021 if (!SWIG_IsOK(res1)) {
43022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43023 }
43024 arg1 = reinterpret_cast< wxMenu * >(argp1);
43025 ecode2 = SWIG_AsVal_int(obj1, &val2);
43026 if (!SWIG_IsOK(ecode2)) {
43027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43028 }
43029 arg2 = static_cast< int >(val2);
43030 {
43031 PyThreadState* __tstate = wxPyBeginAllowThreads();
43032 result = (wxMenuItem *)(arg1)->Remove(arg2);
43033 wxPyEndAllowThreads(__tstate);
43034 if (PyErr_Occurred()) SWIG_fail;
43035 }
43036 {
43037 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43038 }
43039 return resultobj;
43040 fail:
43041 return NULL;
43042 }
43043
43044
43045 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43046 PyObject *resultobj = 0;
43047 wxMenu *arg1 = (wxMenu *) 0 ;
43048 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43049 wxMenuItem *result = 0 ;
43050 void *argp1 = 0 ;
43051 int res1 = 0 ;
43052 void *argp2 = 0 ;
43053 int res2 = 0 ;
43054 PyObject * obj0 = 0 ;
43055 PyObject * obj1 = 0 ;
43056 char * kwnames[] = {
43057 (char *) "self",(char *) "item", NULL
43058 };
43059
43060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43062 if (!SWIG_IsOK(res1)) {
43063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43064 }
43065 arg1 = reinterpret_cast< wxMenu * >(argp1);
43066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43067 if (!SWIG_IsOK(res2)) {
43068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43069 }
43070 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43071 {
43072 PyThreadState* __tstate = wxPyBeginAllowThreads();
43073 result = (wxMenuItem *)(arg1)->Remove(arg2);
43074 wxPyEndAllowThreads(__tstate);
43075 if (PyErr_Occurred()) SWIG_fail;
43076 }
43077 {
43078 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43079 }
43080 return resultobj;
43081 fail:
43082 return NULL;
43083 }
43084
43085
43086 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43087 PyObject *resultobj = 0;
43088 wxMenu *arg1 = (wxMenu *) 0 ;
43089 int arg2 ;
43090 bool result;
43091 void *argp1 = 0 ;
43092 int res1 = 0 ;
43093 int val2 ;
43094 int ecode2 = 0 ;
43095 PyObject * obj0 = 0 ;
43096 PyObject * obj1 = 0 ;
43097 char * kwnames[] = {
43098 (char *) "self",(char *) "id", NULL
43099 };
43100
43101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43103 if (!SWIG_IsOK(res1)) {
43104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43105 }
43106 arg1 = reinterpret_cast< wxMenu * >(argp1);
43107 ecode2 = SWIG_AsVal_int(obj1, &val2);
43108 if (!SWIG_IsOK(ecode2)) {
43109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43110 }
43111 arg2 = static_cast< int >(val2);
43112 {
43113 PyThreadState* __tstate = wxPyBeginAllowThreads();
43114 result = (bool)(arg1)->Delete(arg2);
43115 wxPyEndAllowThreads(__tstate);
43116 if (PyErr_Occurred()) SWIG_fail;
43117 }
43118 {
43119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43120 }
43121 return resultobj;
43122 fail:
43123 return NULL;
43124 }
43125
43126
43127 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43128 PyObject *resultobj = 0;
43129 wxMenu *arg1 = (wxMenu *) 0 ;
43130 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43131 bool result;
43132 void *argp1 = 0 ;
43133 int res1 = 0 ;
43134 void *argp2 = 0 ;
43135 int res2 = 0 ;
43136 PyObject * obj0 = 0 ;
43137 PyObject * obj1 = 0 ;
43138 char * kwnames[] = {
43139 (char *) "self",(char *) "item", NULL
43140 };
43141
43142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43144 if (!SWIG_IsOK(res1)) {
43145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43146 }
43147 arg1 = reinterpret_cast< wxMenu * >(argp1);
43148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43149 if (!SWIG_IsOK(res2)) {
43150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43151 }
43152 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43153 {
43154 PyThreadState* __tstate = wxPyBeginAllowThreads();
43155 result = (bool)(arg1)->Delete(arg2);
43156 wxPyEndAllowThreads(__tstate);
43157 if (PyErr_Occurred()) SWIG_fail;
43158 }
43159 {
43160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43161 }
43162 return resultobj;
43163 fail:
43164 return NULL;
43165 }
43166
43167
43168 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43169 PyObject *resultobj = 0;
43170 wxMenu *arg1 = (wxMenu *) 0 ;
43171 void *argp1 = 0 ;
43172 int res1 = 0 ;
43173 PyObject *swig_obj[1] ;
43174
43175 if (!args) SWIG_fail;
43176 swig_obj[0] = args;
43177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43178 if (!SWIG_IsOK(res1)) {
43179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43180 }
43181 arg1 = reinterpret_cast< wxMenu * >(argp1);
43182 {
43183 PyThreadState* __tstate = wxPyBeginAllowThreads();
43184 wxMenu_Destroy(arg1);
43185 wxPyEndAllowThreads(__tstate);
43186 if (PyErr_Occurred()) SWIG_fail;
43187 }
43188 resultobj = SWIG_Py_Void();
43189 return resultobj;
43190 fail:
43191 return NULL;
43192 }
43193
43194
43195 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43196 PyObject *resultobj = 0;
43197 wxMenu *arg1 = (wxMenu *) 0 ;
43198 int arg2 ;
43199 bool result;
43200 void *argp1 = 0 ;
43201 int res1 = 0 ;
43202 int val2 ;
43203 int ecode2 = 0 ;
43204 PyObject * obj0 = 0 ;
43205 PyObject * obj1 = 0 ;
43206 char * kwnames[] = {
43207 (char *) "self",(char *) "id", NULL
43208 };
43209
43210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43212 if (!SWIG_IsOK(res1)) {
43213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43214 }
43215 arg1 = reinterpret_cast< wxMenu * >(argp1);
43216 ecode2 = SWIG_AsVal_int(obj1, &val2);
43217 if (!SWIG_IsOK(ecode2)) {
43218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43219 }
43220 arg2 = static_cast< int >(val2);
43221 {
43222 PyThreadState* __tstate = wxPyBeginAllowThreads();
43223 result = (bool)(arg1)->Destroy(arg2);
43224 wxPyEndAllowThreads(__tstate);
43225 if (PyErr_Occurred()) SWIG_fail;
43226 }
43227 {
43228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43229 }
43230 return resultobj;
43231 fail:
43232 return NULL;
43233 }
43234
43235
43236 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43237 PyObject *resultobj = 0;
43238 wxMenu *arg1 = (wxMenu *) 0 ;
43239 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43240 bool result;
43241 void *argp1 = 0 ;
43242 int res1 = 0 ;
43243 void *argp2 = 0 ;
43244 int res2 = 0 ;
43245 PyObject * obj0 = 0 ;
43246 PyObject * obj1 = 0 ;
43247 char * kwnames[] = {
43248 (char *) "self",(char *) "item", NULL
43249 };
43250
43251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43253 if (!SWIG_IsOK(res1)) {
43254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43255 }
43256 arg1 = reinterpret_cast< wxMenu * >(argp1);
43257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43258 if (!SWIG_IsOK(res2)) {
43259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43260 }
43261 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 result = (bool)(arg1)->Destroy(arg2);
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 {
43269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43270 }
43271 return resultobj;
43272 fail:
43273 return NULL;
43274 }
43275
43276
43277 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43278 PyObject *resultobj = 0;
43279 wxMenu *arg1 = (wxMenu *) 0 ;
43280 size_t result;
43281 void *argp1 = 0 ;
43282 int res1 = 0 ;
43283 PyObject *swig_obj[1] ;
43284
43285 if (!args) SWIG_fail;
43286 swig_obj[0] = args;
43287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43288 if (!SWIG_IsOK(res1)) {
43289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43290 }
43291 arg1 = reinterpret_cast< wxMenu * >(argp1);
43292 {
43293 PyThreadState* __tstate = wxPyBeginAllowThreads();
43294 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43295 wxPyEndAllowThreads(__tstate);
43296 if (PyErr_Occurred()) SWIG_fail;
43297 }
43298 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43299 return resultobj;
43300 fail:
43301 return NULL;
43302 }
43303
43304
43305 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43306 PyObject *resultobj = 0;
43307 wxMenu *arg1 = (wxMenu *) 0 ;
43308 PyObject *result = 0 ;
43309 void *argp1 = 0 ;
43310 int res1 = 0 ;
43311 PyObject *swig_obj[1] ;
43312
43313 if (!args) SWIG_fail;
43314 swig_obj[0] = args;
43315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43316 if (!SWIG_IsOK(res1)) {
43317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43318 }
43319 arg1 = reinterpret_cast< wxMenu * >(argp1);
43320 {
43321 PyThreadState* __tstate = wxPyBeginAllowThreads();
43322 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43323 wxPyEndAllowThreads(__tstate);
43324 if (PyErr_Occurred()) SWIG_fail;
43325 }
43326 resultobj = result;
43327 return resultobj;
43328 fail:
43329 return NULL;
43330 }
43331
43332
43333 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43334 PyObject *resultobj = 0;
43335 wxMenu *arg1 = (wxMenu *) 0 ;
43336 wxString *arg2 = 0 ;
43337 int result;
43338 void *argp1 = 0 ;
43339 int res1 = 0 ;
43340 bool temp2 = false ;
43341 PyObject * obj0 = 0 ;
43342 PyObject * obj1 = 0 ;
43343 char * kwnames[] = {
43344 (char *) "self",(char *) "item", NULL
43345 };
43346
43347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43349 if (!SWIG_IsOK(res1)) {
43350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43351 }
43352 arg1 = reinterpret_cast< wxMenu * >(argp1);
43353 {
43354 arg2 = wxString_in_helper(obj1);
43355 if (arg2 == NULL) SWIG_fail;
43356 temp2 = true;
43357 }
43358 {
43359 PyThreadState* __tstate = wxPyBeginAllowThreads();
43360 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43361 wxPyEndAllowThreads(__tstate);
43362 if (PyErr_Occurred()) SWIG_fail;
43363 }
43364 resultobj = SWIG_From_int(static_cast< int >(result));
43365 {
43366 if (temp2)
43367 delete arg2;
43368 }
43369 return resultobj;
43370 fail:
43371 {
43372 if (temp2)
43373 delete arg2;
43374 }
43375 return NULL;
43376 }
43377
43378
43379 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43380 PyObject *resultobj = 0;
43381 wxMenu *arg1 = (wxMenu *) 0 ;
43382 int arg2 ;
43383 wxMenuItem *result = 0 ;
43384 void *argp1 = 0 ;
43385 int res1 = 0 ;
43386 int val2 ;
43387 int ecode2 = 0 ;
43388 PyObject * obj0 = 0 ;
43389 PyObject * obj1 = 0 ;
43390 char * kwnames[] = {
43391 (char *) "self",(char *) "id", NULL
43392 };
43393
43394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43396 if (!SWIG_IsOK(res1)) {
43397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43398 }
43399 arg1 = reinterpret_cast< wxMenu * >(argp1);
43400 ecode2 = SWIG_AsVal_int(obj1, &val2);
43401 if (!SWIG_IsOK(ecode2)) {
43402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43403 }
43404 arg2 = static_cast< int >(val2);
43405 {
43406 PyThreadState* __tstate = wxPyBeginAllowThreads();
43407 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 {
43412 resultobj = wxPyMake_wxObject(result, (bool)0);
43413 }
43414 return resultobj;
43415 fail:
43416 return NULL;
43417 }
43418
43419
43420 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43421 PyObject *resultobj = 0;
43422 wxMenu *arg1 = (wxMenu *) 0 ;
43423 size_t arg2 ;
43424 wxMenuItem *result = 0 ;
43425 void *argp1 = 0 ;
43426 int res1 = 0 ;
43427 size_t val2 ;
43428 int ecode2 = 0 ;
43429 PyObject * obj0 = 0 ;
43430 PyObject * obj1 = 0 ;
43431 char * kwnames[] = {
43432 (char *) "self",(char *) "position", NULL
43433 };
43434
43435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43437 if (!SWIG_IsOK(res1)) {
43438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43439 }
43440 arg1 = reinterpret_cast< wxMenu * >(argp1);
43441 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43442 if (!SWIG_IsOK(ecode2)) {
43443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43444 }
43445 arg2 = static_cast< size_t >(val2);
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43449 wxPyEndAllowThreads(__tstate);
43450 if (PyErr_Occurred()) SWIG_fail;
43451 }
43452 {
43453 resultobj = wxPyMake_wxObject(result, (bool)0);
43454 }
43455 return resultobj;
43456 fail:
43457 return NULL;
43458 }
43459
43460
43461 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43462 PyObject *resultobj = 0;
43463 wxMenu *arg1 = (wxMenu *) 0 ;
43464 int arg2 ;
43465 bool arg3 ;
43466 void *argp1 = 0 ;
43467 int res1 = 0 ;
43468 int val2 ;
43469 int ecode2 = 0 ;
43470 bool val3 ;
43471 int ecode3 = 0 ;
43472 PyObject * obj0 = 0 ;
43473 PyObject * obj1 = 0 ;
43474 PyObject * obj2 = 0 ;
43475 char * kwnames[] = {
43476 (char *) "self",(char *) "id",(char *) "enable", NULL
43477 };
43478
43479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43481 if (!SWIG_IsOK(res1)) {
43482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43483 }
43484 arg1 = reinterpret_cast< wxMenu * >(argp1);
43485 ecode2 = SWIG_AsVal_int(obj1, &val2);
43486 if (!SWIG_IsOK(ecode2)) {
43487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43488 }
43489 arg2 = static_cast< int >(val2);
43490 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43491 if (!SWIG_IsOK(ecode3)) {
43492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43493 }
43494 arg3 = static_cast< bool >(val3);
43495 {
43496 PyThreadState* __tstate = wxPyBeginAllowThreads();
43497 (arg1)->Enable(arg2,arg3);
43498 wxPyEndAllowThreads(__tstate);
43499 if (PyErr_Occurred()) SWIG_fail;
43500 }
43501 resultobj = SWIG_Py_Void();
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj = 0;
43510 wxMenu *arg1 = (wxMenu *) 0 ;
43511 int arg2 ;
43512 bool result;
43513 void *argp1 = 0 ;
43514 int res1 = 0 ;
43515 int val2 ;
43516 int ecode2 = 0 ;
43517 PyObject * obj0 = 0 ;
43518 PyObject * obj1 = 0 ;
43519 char * kwnames[] = {
43520 (char *) "self",(char *) "id", NULL
43521 };
43522
43523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43525 if (!SWIG_IsOK(res1)) {
43526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43527 }
43528 arg1 = reinterpret_cast< wxMenu * >(argp1);
43529 ecode2 = SWIG_AsVal_int(obj1, &val2);
43530 if (!SWIG_IsOK(ecode2)) {
43531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43532 }
43533 arg2 = static_cast< int >(val2);
43534 {
43535 PyThreadState* __tstate = wxPyBeginAllowThreads();
43536 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43537 wxPyEndAllowThreads(__tstate);
43538 if (PyErr_Occurred()) SWIG_fail;
43539 }
43540 {
43541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43542 }
43543 return resultobj;
43544 fail:
43545 return NULL;
43546 }
43547
43548
43549 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43550 PyObject *resultobj = 0;
43551 wxMenu *arg1 = (wxMenu *) 0 ;
43552 int arg2 ;
43553 bool arg3 ;
43554 void *argp1 = 0 ;
43555 int res1 = 0 ;
43556 int val2 ;
43557 int ecode2 = 0 ;
43558 bool val3 ;
43559 int ecode3 = 0 ;
43560 PyObject * obj0 = 0 ;
43561 PyObject * obj1 = 0 ;
43562 PyObject * obj2 = 0 ;
43563 char * kwnames[] = {
43564 (char *) "self",(char *) "id",(char *) "check", NULL
43565 };
43566
43567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43569 if (!SWIG_IsOK(res1)) {
43570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43571 }
43572 arg1 = reinterpret_cast< wxMenu * >(argp1);
43573 ecode2 = SWIG_AsVal_int(obj1, &val2);
43574 if (!SWIG_IsOK(ecode2)) {
43575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43576 }
43577 arg2 = static_cast< int >(val2);
43578 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43579 if (!SWIG_IsOK(ecode3)) {
43580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43581 }
43582 arg3 = static_cast< bool >(val3);
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 (arg1)->Check(arg2,arg3);
43586 wxPyEndAllowThreads(__tstate);
43587 if (PyErr_Occurred()) SWIG_fail;
43588 }
43589 resultobj = SWIG_Py_Void();
43590 return resultobj;
43591 fail:
43592 return NULL;
43593 }
43594
43595
43596 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43597 PyObject *resultobj = 0;
43598 wxMenu *arg1 = (wxMenu *) 0 ;
43599 int arg2 ;
43600 bool result;
43601 void *argp1 = 0 ;
43602 int res1 = 0 ;
43603 int val2 ;
43604 int ecode2 = 0 ;
43605 PyObject * obj0 = 0 ;
43606 PyObject * obj1 = 0 ;
43607 char * kwnames[] = {
43608 (char *) "self",(char *) "id", NULL
43609 };
43610
43611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43613 if (!SWIG_IsOK(res1)) {
43614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43615 }
43616 arg1 = reinterpret_cast< wxMenu * >(argp1);
43617 ecode2 = SWIG_AsVal_int(obj1, &val2);
43618 if (!SWIG_IsOK(ecode2)) {
43619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43620 }
43621 arg2 = static_cast< int >(val2);
43622 {
43623 PyThreadState* __tstate = wxPyBeginAllowThreads();
43624 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 {
43629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43630 }
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj = 0;
43639 wxMenu *arg1 = (wxMenu *) 0 ;
43640 int arg2 ;
43641 wxString *arg3 = 0 ;
43642 void *argp1 = 0 ;
43643 int res1 = 0 ;
43644 int val2 ;
43645 int ecode2 = 0 ;
43646 bool temp3 = false ;
43647 PyObject * obj0 = 0 ;
43648 PyObject * obj1 = 0 ;
43649 PyObject * obj2 = 0 ;
43650 char * kwnames[] = {
43651 (char *) "self",(char *) "id",(char *) "label", NULL
43652 };
43653
43654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenu * >(argp1);
43660 ecode2 = SWIG_AsVal_int(obj1, &val2);
43661 if (!SWIG_IsOK(ecode2)) {
43662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43663 }
43664 arg2 = static_cast< int >(val2);
43665 {
43666 arg3 = wxString_in_helper(obj2);
43667 if (arg3 == NULL) SWIG_fail;
43668 temp3 = true;
43669 }
43670 {
43671 PyThreadState* __tstate = wxPyBeginAllowThreads();
43672 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43673 wxPyEndAllowThreads(__tstate);
43674 if (PyErr_Occurred()) SWIG_fail;
43675 }
43676 resultobj = SWIG_Py_Void();
43677 {
43678 if (temp3)
43679 delete arg3;
43680 }
43681 return resultobj;
43682 fail:
43683 {
43684 if (temp3)
43685 delete arg3;
43686 }
43687 return NULL;
43688 }
43689
43690
43691 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43692 PyObject *resultobj = 0;
43693 wxMenu *arg1 = (wxMenu *) 0 ;
43694 int arg2 ;
43695 wxString result;
43696 void *argp1 = 0 ;
43697 int res1 = 0 ;
43698 int val2 ;
43699 int ecode2 = 0 ;
43700 PyObject * obj0 = 0 ;
43701 PyObject * obj1 = 0 ;
43702 char * kwnames[] = {
43703 (char *) "self",(char *) "id", NULL
43704 };
43705
43706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43708 if (!SWIG_IsOK(res1)) {
43709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43710 }
43711 arg1 = reinterpret_cast< wxMenu * >(argp1);
43712 ecode2 = SWIG_AsVal_int(obj1, &val2);
43713 if (!SWIG_IsOK(ecode2)) {
43714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43715 }
43716 arg2 = static_cast< int >(val2);
43717 {
43718 PyThreadState* __tstate = wxPyBeginAllowThreads();
43719 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 {
43724 #if wxUSE_UNICODE
43725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43726 #else
43727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43728 #endif
43729 }
43730 return resultobj;
43731 fail:
43732 return NULL;
43733 }
43734
43735
43736 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43737 PyObject *resultobj = 0;
43738 wxMenu *arg1 = (wxMenu *) 0 ;
43739 int arg2 ;
43740 wxString *arg3 = 0 ;
43741 void *argp1 = 0 ;
43742 int res1 = 0 ;
43743 int val2 ;
43744 int ecode2 = 0 ;
43745 bool temp3 = false ;
43746 PyObject * obj0 = 0 ;
43747 PyObject * obj1 = 0 ;
43748 PyObject * obj2 = 0 ;
43749 char * kwnames[] = {
43750 (char *) "self",(char *) "id",(char *) "helpString", NULL
43751 };
43752
43753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43757 }
43758 arg1 = reinterpret_cast< wxMenu * >(argp1);
43759 ecode2 = SWIG_AsVal_int(obj1, &val2);
43760 if (!SWIG_IsOK(ecode2)) {
43761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43762 }
43763 arg2 = static_cast< int >(val2);
43764 {
43765 arg3 = wxString_in_helper(obj2);
43766 if (arg3 == NULL) SWIG_fail;
43767 temp3 = true;
43768 }
43769 {
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43772 wxPyEndAllowThreads(__tstate);
43773 if (PyErr_Occurred()) SWIG_fail;
43774 }
43775 resultobj = SWIG_Py_Void();
43776 {
43777 if (temp3)
43778 delete arg3;
43779 }
43780 return resultobj;
43781 fail:
43782 {
43783 if (temp3)
43784 delete arg3;
43785 }
43786 return NULL;
43787 }
43788
43789
43790 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43791 PyObject *resultobj = 0;
43792 wxMenu *arg1 = (wxMenu *) 0 ;
43793 int arg2 ;
43794 wxString result;
43795 void *argp1 = 0 ;
43796 int res1 = 0 ;
43797 int val2 ;
43798 int ecode2 = 0 ;
43799 PyObject * obj0 = 0 ;
43800 PyObject * obj1 = 0 ;
43801 char * kwnames[] = {
43802 (char *) "self",(char *) "id", NULL
43803 };
43804
43805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43807 if (!SWIG_IsOK(res1)) {
43808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43809 }
43810 arg1 = reinterpret_cast< wxMenu * >(argp1);
43811 ecode2 = SWIG_AsVal_int(obj1, &val2);
43812 if (!SWIG_IsOK(ecode2)) {
43813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43814 }
43815 arg2 = static_cast< int >(val2);
43816 {
43817 PyThreadState* __tstate = wxPyBeginAllowThreads();
43818 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43819 wxPyEndAllowThreads(__tstate);
43820 if (PyErr_Occurred()) SWIG_fail;
43821 }
43822 {
43823 #if wxUSE_UNICODE
43824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43825 #else
43826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43827 #endif
43828 }
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43836 PyObject *resultobj = 0;
43837 wxMenu *arg1 = (wxMenu *) 0 ;
43838 wxString *arg2 = 0 ;
43839 void *argp1 = 0 ;
43840 int res1 = 0 ;
43841 bool temp2 = false ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "title", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43852 }
43853 arg1 = reinterpret_cast< wxMenu * >(argp1);
43854 {
43855 arg2 = wxString_in_helper(obj1);
43856 if (arg2 == NULL) SWIG_fail;
43857 temp2 = true;
43858 }
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 (arg1)->SetTitle((wxString const &)*arg2);
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 resultobj = SWIG_Py_Void();
43866 {
43867 if (temp2)
43868 delete arg2;
43869 }
43870 return resultobj;
43871 fail:
43872 {
43873 if (temp2)
43874 delete arg2;
43875 }
43876 return NULL;
43877 }
43878
43879
43880 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43881 PyObject *resultobj = 0;
43882 wxMenu *arg1 = (wxMenu *) 0 ;
43883 wxString result;
43884 void *argp1 = 0 ;
43885 int res1 = 0 ;
43886 PyObject *swig_obj[1] ;
43887
43888 if (!args) SWIG_fail;
43889 swig_obj[0] = args;
43890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43891 if (!SWIG_IsOK(res1)) {
43892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43893 }
43894 arg1 = reinterpret_cast< wxMenu * >(argp1);
43895 {
43896 PyThreadState* __tstate = wxPyBeginAllowThreads();
43897 result = ((wxMenu const *)arg1)->GetTitle();
43898 wxPyEndAllowThreads(__tstate);
43899 if (PyErr_Occurred()) SWIG_fail;
43900 }
43901 {
43902 #if wxUSE_UNICODE
43903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43904 #else
43905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43906 #endif
43907 }
43908 return resultobj;
43909 fail:
43910 return NULL;
43911 }
43912
43913
43914 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43915 PyObject *resultobj = 0;
43916 wxMenu *arg1 = (wxMenu *) 0 ;
43917 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43918 void *argp1 = 0 ;
43919 int res1 = 0 ;
43920 void *argp2 = 0 ;
43921 int res2 = 0 ;
43922 PyObject * obj0 = 0 ;
43923 PyObject * obj1 = 0 ;
43924 char * kwnames[] = {
43925 (char *) "self",(char *) "handler", NULL
43926 };
43927
43928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43930 if (!SWIG_IsOK(res1)) {
43931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43932 }
43933 arg1 = reinterpret_cast< wxMenu * >(argp1);
43934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43935 if (!SWIG_IsOK(res2)) {
43936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43937 }
43938 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43939 {
43940 PyThreadState* __tstate = wxPyBeginAllowThreads();
43941 (arg1)->SetEventHandler(arg2);
43942 wxPyEndAllowThreads(__tstate);
43943 if (PyErr_Occurred()) SWIG_fail;
43944 }
43945 resultobj = SWIG_Py_Void();
43946 return resultobj;
43947 fail:
43948 return NULL;
43949 }
43950
43951
43952 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43953 PyObject *resultobj = 0;
43954 wxMenu *arg1 = (wxMenu *) 0 ;
43955 wxEvtHandler *result = 0 ;
43956 void *argp1 = 0 ;
43957 int res1 = 0 ;
43958 PyObject *swig_obj[1] ;
43959
43960 if (!args) SWIG_fail;
43961 swig_obj[0] = args;
43962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43963 if (!SWIG_IsOK(res1)) {
43964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43965 }
43966 arg1 = reinterpret_cast< wxMenu * >(argp1);
43967 {
43968 PyThreadState* __tstate = wxPyBeginAllowThreads();
43969 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 {
43974 resultobj = wxPyMake_wxObject(result, 0);
43975 }
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj = 0;
43984 wxMenu *arg1 = (wxMenu *) 0 ;
43985 wxWindow *arg2 = (wxWindow *) 0 ;
43986 void *argp1 = 0 ;
43987 int res1 = 0 ;
43988 void *argp2 = 0 ;
43989 int res2 = 0 ;
43990 PyObject * obj0 = 0 ;
43991 PyObject * obj1 = 0 ;
43992 char * kwnames[] = {
43993 (char *) "self",(char *) "win", NULL
43994 };
43995
43996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
43997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43998 if (!SWIG_IsOK(res1)) {
43999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44000 }
44001 arg1 = reinterpret_cast< wxMenu * >(argp1);
44002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44003 if (!SWIG_IsOK(res2)) {
44004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44005 }
44006 arg2 = reinterpret_cast< wxWindow * >(argp2);
44007 {
44008 PyThreadState* __tstate = wxPyBeginAllowThreads();
44009 (arg1)->SetInvokingWindow(arg2);
44010 wxPyEndAllowThreads(__tstate);
44011 if (PyErr_Occurred()) SWIG_fail;
44012 }
44013 resultobj = SWIG_Py_Void();
44014 return resultobj;
44015 fail:
44016 return NULL;
44017 }
44018
44019
44020 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44021 PyObject *resultobj = 0;
44022 wxMenu *arg1 = (wxMenu *) 0 ;
44023 wxWindow *result = 0 ;
44024 void *argp1 = 0 ;
44025 int res1 = 0 ;
44026 PyObject *swig_obj[1] ;
44027
44028 if (!args) SWIG_fail;
44029 swig_obj[0] = args;
44030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44031 if (!SWIG_IsOK(res1)) {
44032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44033 }
44034 arg1 = reinterpret_cast< wxMenu * >(argp1);
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 {
44042 resultobj = wxPyMake_wxObject(result, 0);
44043 }
44044 return resultobj;
44045 fail:
44046 return NULL;
44047 }
44048
44049
44050 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44051 PyObject *resultobj = 0;
44052 wxMenu *arg1 = (wxMenu *) 0 ;
44053 long result;
44054 void *argp1 = 0 ;
44055 int res1 = 0 ;
44056 PyObject *swig_obj[1] ;
44057
44058 if (!args) SWIG_fail;
44059 swig_obj[0] = args;
44060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44061 if (!SWIG_IsOK(res1)) {
44062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44063 }
44064 arg1 = reinterpret_cast< wxMenu * >(argp1);
44065 {
44066 PyThreadState* __tstate = wxPyBeginAllowThreads();
44067 result = (long)((wxMenu const *)arg1)->GetStyle();
44068 wxPyEndAllowThreads(__tstate);
44069 if (PyErr_Occurred()) SWIG_fail;
44070 }
44071 resultobj = SWIG_From_long(static_cast< long >(result));
44072 return resultobj;
44073 fail:
44074 return NULL;
44075 }
44076
44077
44078 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44079 PyObject *resultobj = 0;
44080 wxMenu *arg1 = (wxMenu *) 0 ;
44081 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44082 void *argp1 = 0 ;
44083 int res1 = 0 ;
44084 void *argp2 = 0 ;
44085 int res2 = 0 ;
44086 PyObject * obj0 = 0 ;
44087 PyObject * obj1 = 0 ;
44088 char * kwnames[] = {
44089 (char *) "self",(char *) "source", NULL
44090 };
44091
44092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44094 if (!SWIG_IsOK(res1)) {
44095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44096 }
44097 arg1 = reinterpret_cast< wxMenu * >(argp1);
44098 if (obj1) {
44099 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44100 if (!SWIG_IsOK(res2)) {
44101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44102 }
44103 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44104 }
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 (arg1)->UpdateUI(arg2);
44108 wxPyEndAllowThreads(__tstate);
44109 if (PyErr_Occurred()) SWIG_fail;
44110 }
44111 resultobj = SWIG_Py_Void();
44112 return resultobj;
44113 fail:
44114 return NULL;
44115 }
44116
44117
44118 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44119 PyObject *resultobj = 0;
44120 wxMenu *arg1 = (wxMenu *) 0 ;
44121 wxMenuBar *result = 0 ;
44122 void *argp1 = 0 ;
44123 int res1 = 0 ;
44124 PyObject *swig_obj[1] ;
44125
44126 if (!args) SWIG_fail;
44127 swig_obj[0] = args;
44128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44129 if (!SWIG_IsOK(res1)) {
44130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44131 }
44132 arg1 = reinterpret_cast< wxMenu * >(argp1);
44133 {
44134 PyThreadState* __tstate = wxPyBeginAllowThreads();
44135 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44136 wxPyEndAllowThreads(__tstate);
44137 if (PyErr_Occurred()) SWIG_fail;
44138 }
44139 {
44140 resultobj = wxPyMake_wxObject(result, (bool)0);
44141 }
44142 return resultobj;
44143 fail:
44144 return NULL;
44145 }
44146
44147
44148 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44149 PyObject *resultobj = 0;
44150 wxMenu *arg1 = (wxMenu *) 0 ;
44151 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44152 void *argp1 = 0 ;
44153 int res1 = 0 ;
44154 void *argp2 = 0 ;
44155 int res2 = 0 ;
44156 PyObject * obj0 = 0 ;
44157 PyObject * obj1 = 0 ;
44158 char * kwnames[] = {
44159 (char *) "self",(char *) "menubar", NULL
44160 };
44161
44162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44164 if (!SWIG_IsOK(res1)) {
44165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44166 }
44167 arg1 = reinterpret_cast< wxMenu * >(argp1);
44168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44169 if (!SWIG_IsOK(res2)) {
44170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44171 }
44172 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44173 {
44174 PyThreadState* __tstate = wxPyBeginAllowThreads();
44175 (arg1)->Attach(arg2);
44176 wxPyEndAllowThreads(__tstate);
44177 if (PyErr_Occurred()) SWIG_fail;
44178 }
44179 resultobj = SWIG_Py_Void();
44180 return resultobj;
44181 fail:
44182 return NULL;
44183 }
44184
44185
44186 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44187 PyObject *resultobj = 0;
44188 wxMenu *arg1 = (wxMenu *) 0 ;
44189 void *argp1 = 0 ;
44190 int res1 = 0 ;
44191 PyObject *swig_obj[1] ;
44192
44193 if (!args) SWIG_fail;
44194 swig_obj[0] = args;
44195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44196 if (!SWIG_IsOK(res1)) {
44197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44198 }
44199 arg1 = reinterpret_cast< wxMenu * >(argp1);
44200 {
44201 PyThreadState* __tstate = wxPyBeginAllowThreads();
44202 (arg1)->Detach();
44203 wxPyEndAllowThreads(__tstate);
44204 if (PyErr_Occurred()) SWIG_fail;
44205 }
44206 resultobj = SWIG_Py_Void();
44207 return resultobj;
44208 fail:
44209 return NULL;
44210 }
44211
44212
44213 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44214 PyObject *resultobj = 0;
44215 wxMenu *arg1 = (wxMenu *) 0 ;
44216 bool result;
44217 void *argp1 = 0 ;
44218 int res1 = 0 ;
44219 PyObject *swig_obj[1] ;
44220
44221 if (!args) SWIG_fail;
44222 swig_obj[0] = args;
44223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44224 if (!SWIG_IsOK(res1)) {
44225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44226 }
44227 arg1 = reinterpret_cast< wxMenu * >(argp1);
44228 {
44229 PyThreadState* __tstate = wxPyBeginAllowThreads();
44230 result = (bool)((wxMenu const *)arg1)->IsAttached();
44231 wxPyEndAllowThreads(__tstate);
44232 if (PyErr_Occurred()) SWIG_fail;
44233 }
44234 {
44235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44236 }
44237 return resultobj;
44238 fail:
44239 return NULL;
44240 }
44241
44242
44243 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44244 PyObject *resultobj = 0;
44245 wxMenu *arg1 = (wxMenu *) 0 ;
44246 wxMenu *arg2 = (wxMenu *) 0 ;
44247 void *argp1 = 0 ;
44248 int res1 = 0 ;
44249 void *argp2 = 0 ;
44250 int res2 = 0 ;
44251 PyObject * obj0 = 0 ;
44252 PyObject * obj1 = 0 ;
44253 char * kwnames[] = {
44254 (char *) "self",(char *) "parent", NULL
44255 };
44256
44257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44259 if (!SWIG_IsOK(res1)) {
44260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44261 }
44262 arg1 = reinterpret_cast< wxMenu * >(argp1);
44263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44264 if (!SWIG_IsOK(res2)) {
44265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44266 }
44267 arg2 = reinterpret_cast< wxMenu * >(argp2);
44268 {
44269 PyThreadState* __tstate = wxPyBeginAllowThreads();
44270 (arg1)->SetParent(arg2);
44271 wxPyEndAllowThreads(__tstate);
44272 if (PyErr_Occurred()) SWIG_fail;
44273 }
44274 resultobj = SWIG_Py_Void();
44275 return resultobj;
44276 fail:
44277 return NULL;
44278 }
44279
44280
44281 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44282 PyObject *resultobj = 0;
44283 wxMenu *arg1 = (wxMenu *) 0 ;
44284 wxMenu *result = 0 ;
44285 void *argp1 = 0 ;
44286 int res1 = 0 ;
44287 PyObject *swig_obj[1] ;
44288
44289 if (!args) SWIG_fail;
44290 swig_obj[0] = args;
44291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44292 if (!SWIG_IsOK(res1)) {
44293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44294 }
44295 arg1 = reinterpret_cast< wxMenu * >(argp1);
44296 {
44297 PyThreadState* __tstate = wxPyBeginAllowThreads();
44298 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44299 wxPyEndAllowThreads(__tstate);
44300 if (PyErr_Occurred()) SWIG_fail;
44301 }
44302 {
44303 resultobj = wxPyMake_wxObject(result, 0);
44304 }
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44312 PyObject *obj;
44313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44314 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44315 return SWIG_Py_Void();
44316 }
44317
44318 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44319 return SWIG_Python_InitShadowInstance(args);
44320 }
44321
44322 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44323 PyObject *resultobj = 0;
44324 long arg1 = (long) 0 ;
44325 wxMenuBar *result = 0 ;
44326 long val1 ;
44327 int ecode1 = 0 ;
44328 PyObject * obj0 = 0 ;
44329 char * kwnames[] = {
44330 (char *) "style", NULL
44331 };
44332
44333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44334 if (obj0) {
44335 ecode1 = SWIG_AsVal_long(obj0, &val1);
44336 if (!SWIG_IsOK(ecode1)) {
44337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44338 }
44339 arg1 = static_cast< long >(val1);
44340 }
44341 {
44342 if (!wxPyCheckForApp()) SWIG_fail;
44343 PyThreadState* __tstate = wxPyBeginAllowThreads();
44344 result = (wxMenuBar *)new wxMenuBar(arg1);
44345 wxPyEndAllowThreads(__tstate);
44346 if (PyErr_Occurred()) SWIG_fail;
44347 }
44348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44349 return resultobj;
44350 fail:
44351 return NULL;
44352 }
44353
44354
44355 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44356 PyObject *resultobj = 0;
44357 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44358 wxMenu *arg2 = (wxMenu *) 0 ;
44359 wxString *arg3 = 0 ;
44360 bool result;
44361 void *argp1 = 0 ;
44362 int res1 = 0 ;
44363 void *argp2 = 0 ;
44364 int res2 = 0 ;
44365 bool temp3 = false ;
44366 PyObject * obj0 = 0 ;
44367 PyObject * obj1 = 0 ;
44368 PyObject * obj2 = 0 ;
44369 char * kwnames[] = {
44370 (char *) "self",(char *) "menu",(char *) "title", NULL
44371 };
44372
44373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44375 if (!SWIG_IsOK(res1)) {
44376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44377 }
44378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44380 if (!SWIG_IsOK(res2)) {
44381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44382 }
44383 arg2 = reinterpret_cast< wxMenu * >(argp2);
44384 {
44385 arg3 = wxString_in_helper(obj2);
44386 if (arg3 == NULL) SWIG_fail;
44387 temp3 = true;
44388 }
44389 {
44390 PyThreadState* __tstate = wxPyBeginAllowThreads();
44391 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44392 wxPyEndAllowThreads(__tstate);
44393 if (PyErr_Occurred()) SWIG_fail;
44394 }
44395 {
44396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44397 }
44398 {
44399 if (temp3)
44400 delete arg3;
44401 }
44402 return resultobj;
44403 fail:
44404 {
44405 if (temp3)
44406 delete arg3;
44407 }
44408 return NULL;
44409 }
44410
44411
44412 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44413 PyObject *resultobj = 0;
44414 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44415 size_t arg2 ;
44416 wxMenu *arg3 = (wxMenu *) 0 ;
44417 wxString *arg4 = 0 ;
44418 bool result;
44419 void *argp1 = 0 ;
44420 int res1 = 0 ;
44421 size_t val2 ;
44422 int ecode2 = 0 ;
44423 void *argp3 = 0 ;
44424 int res3 = 0 ;
44425 bool temp4 = false ;
44426 PyObject * obj0 = 0 ;
44427 PyObject * obj1 = 0 ;
44428 PyObject * obj2 = 0 ;
44429 PyObject * obj3 = 0 ;
44430 char * kwnames[] = {
44431 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44432 };
44433
44434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44436 if (!SWIG_IsOK(res1)) {
44437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44438 }
44439 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44440 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44441 if (!SWIG_IsOK(ecode2)) {
44442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44443 }
44444 arg2 = static_cast< size_t >(val2);
44445 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44446 if (!SWIG_IsOK(res3)) {
44447 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44448 }
44449 arg3 = reinterpret_cast< wxMenu * >(argp3);
44450 {
44451 arg4 = wxString_in_helper(obj3);
44452 if (arg4 == NULL) SWIG_fail;
44453 temp4 = true;
44454 }
44455 {
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44458 wxPyEndAllowThreads(__tstate);
44459 if (PyErr_Occurred()) SWIG_fail;
44460 }
44461 {
44462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44463 }
44464 {
44465 if (temp4)
44466 delete arg4;
44467 }
44468 return resultobj;
44469 fail:
44470 {
44471 if (temp4)
44472 delete arg4;
44473 }
44474 return NULL;
44475 }
44476
44477
44478 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44479 PyObject *resultobj = 0;
44480 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44481 size_t result;
44482 void *argp1 = 0 ;
44483 int res1 = 0 ;
44484 PyObject *swig_obj[1] ;
44485
44486 if (!args) SWIG_fail;
44487 swig_obj[0] = args;
44488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44489 if (!SWIG_IsOK(res1)) {
44490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44491 }
44492 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44496 wxPyEndAllowThreads(__tstate);
44497 if (PyErr_Occurred()) SWIG_fail;
44498 }
44499 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44500 return resultobj;
44501 fail:
44502 return NULL;
44503 }
44504
44505
44506 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44507 PyObject *resultobj = 0;
44508 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44509 size_t arg2 ;
44510 wxMenu *result = 0 ;
44511 void *argp1 = 0 ;
44512 int res1 = 0 ;
44513 size_t val2 ;
44514 int ecode2 = 0 ;
44515 PyObject * obj0 = 0 ;
44516 PyObject * obj1 = 0 ;
44517 char * kwnames[] = {
44518 (char *) "self",(char *) "pos", NULL
44519 };
44520
44521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44523 if (!SWIG_IsOK(res1)) {
44524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44525 }
44526 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44527 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44528 if (!SWIG_IsOK(ecode2)) {
44529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44530 }
44531 arg2 = static_cast< size_t >(val2);
44532 {
44533 PyThreadState* __tstate = wxPyBeginAllowThreads();
44534 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44535 wxPyEndAllowThreads(__tstate);
44536 if (PyErr_Occurred()) SWIG_fail;
44537 }
44538 {
44539 resultobj = wxPyMake_wxObject(result, 0);
44540 }
44541 return resultobj;
44542 fail:
44543 return NULL;
44544 }
44545
44546
44547 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44548 PyObject *resultobj = 0;
44549 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44550 size_t arg2 ;
44551 wxMenu *arg3 = (wxMenu *) 0 ;
44552 wxString *arg4 = 0 ;
44553 wxMenu *result = 0 ;
44554 void *argp1 = 0 ;
44555 int res1 = 0 ;
44556 size_t val2 ;
44557 int ecode2 = 0 ;
44558 void *argp3 = 0 ;
44559 int res3 = 0 ;
44560 bool temp4 = false ;
44561 PyObject * obj0 = 0 ;
44562 PyObject * obj1 = 0 ;
44563 PyObject * obj2 = 0 ;
44564 PyObject * obj3 = 0 ;
44565 char * kwnames[] = {
44566 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44567 };
44568
44569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44571 if (!SWIG_IsOK(res1)) {
44572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44573 }
44574 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44575 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44576 if (!SWIG_IsOK(ecode2)) {
44577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44578 }
44579 arg2 = static_cast< size_t >(val2);
44580 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44581 if (!SWIG_IsOK(res3)) {
44582 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44583 }
44584 arg3 = reinterpret_cast< wxMenu * >(argp3);
44585 {
44586 arg4 = wxString_in_helper(obj3);
44587 if (arg4 == NULL) SWIG_fail;
44588 temp4 = true;
44589 }
44590 {
44591 PyThreadState* __tstate = wxPyBeginAllowThreads();
44592 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44593 wxPyEndAllowThreads(__tstate);
44594 if (PyErr_Occurred()) SWIG_fail;
44595 }
44596 {
44597 resultobj = wxPyMake_wxObject(result, 0);
44598 }
44599 {
44600 if (temp4)
44601 delete arg4;
44602 }
44603 return resultobj;
44604 fail:
44605 {
44606 if (temp4)
44607 delete arg4;
44608 }
44609 return NULL;
44610 }
44611
44612
44613 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44614 PyObject *resultobj = 0;
44615 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44616 size_t arg2 ;
44617 wxMenu *result = 0 ;
44618 void *argp1 = 0 ;
44619 int res1 = 0 ;
44620 size_t val2 ;
44621 int ecode2 = 0 ;
44622 PyObject * obj0 = 0 ;
44623 PyObject * obj1 = 0 ;
44624 char * kwnames[] = {
44625 (char *) "self",(char *) "pos", NULL
44626 };
44627
44628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44630 if (!SWIG_IsOK(res1)) {
44631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44632 }
44633 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44634 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44635 if (!SWIG_IsOK(ecode2)) {
44636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44637 }
44638 arg2 = static_cast< size_t >(val2);
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 result = (wxMenu *)(arg1)->Remove(arg2);
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 {
44646 resultobj = wxPyMake_wxObject(result, 0);
44647 }
44648 return resultobj;
44649 fail:
44650 return NULL;
44651 }
44652
44653
44654 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44655 PyObject *resultobj = 0;
44656 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44657 size_t arg2 ;
44658 bool arg3 ;
44659 void *argp1 = 0 ;
44660 int res1 = 0 ;
44661 size_t val2 ;
44662 int ecode2 = 0 ;
44663 bool val3 ;
44664 int ecode3 = 0 ;
44665 PyObject * obj0 = 0 ;
44666 PyObject * obj1 = 0 ;
44667 PyObject * obj2 = 0 ;
44668 char * kwnames[] = {
44669 (char *) "self",(char *) "pos",(char *) "enable", NULL
44670 };
44671
44672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44674 if (!SWIG_IsOK(res1)) {
44675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44676 }
44677 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44678 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44679 if (!SWIG_IsOK(ecode2)) {
44680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44681 }
44682 arg2 = static_cast< size_t >(val2);
44683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44684 if (!SWIG_IsOK(ecode3)) {
44685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44686 }
44687 arg3 = static_cast< bool >(val3);
44688 {
44689 PyThreadState* __tstate = wxPyBeginAllowThreads();
44690 (arg1)->EnableTop(arg2,arg3);
44691 wxPyEndAllowThreads(__tstate);
44692 if (PyErr_Occurred()) SWIG_fail;
44693 }
44694 resultobj = SWIG_Py_Void();
44695 return resultobj;
44696 fail:
44697 return NULL;
44698 }
44699
44700
44701 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44702 PyObject *resultobj = 0;
44703 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44704 size_t arg2 ;
44705 bool result;
44706 void *argp1 = 0 ;
44707 int res1 = 0 ;
44708 size_t val2 ;
44709 int ecode2 = 0 ;
44710 PyObject * obj0 = 0 ;
44711 PyObject * obj1 = 0 ;
44712 char * kwnames[] = {
44713 (char *) "self",(char *) "pos", NULL
44714 };
44715
44716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44718 if (!SWIG_IsOK(res1)) {
44719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44720 }
44721 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44722 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44723 if (!SWIG_IsOK(ecode2)) {
44724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44725 }
44726 arg2 = static_cast< size_t >(val2);
44727 {
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 {
44734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44735 }
44736 return resultobj;
44737 fail:
44738 return NULL;
44739 }
44740
44741
44742 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44743 PyObject *resultobj = 0;
44744 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44745 size_t arg2 ;
44746 wxString *arg3 = 0 ;
44747 void *argp1 = 0 ;
44748 int res1 = 0 ;
44749 size_t val2 ;
44750 int ecode2 = 0 ;
44751 bool temp3 = false ;
44752 PyObject * obj0 = 0 ;
44753 PyObject * obj1 = 0 ;
44754 PyObject * obj2 = 0 ;
44755 char * kwnames[] = {
44756 (char *) "self",(char *) "pos",(char *) "label", NULL
44757 };
44758
44759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44761 if (!SWIG_IsOK(res1)) {
44762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44763 }
44764 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44765 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44766 if (!SWIG_IsOK(ecode2)) {
44767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44768 }
44769 arg2 = static_cast< size_t >(val2);
44770 {
44771 arg3 = wxString_in_helper(obj2);
44772 if (arg3 == NULL) SWIG_fail;
44773 temp3 = true;
44774 }
44775 {
44776 PyThreadState* __tstate = wxPyBeginAllowThreads();
44777 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 resultobj = SWIG_Py_Void();
44782 {
44783 if (temp3)
44784 delete arg3;
44785 }
44786 return resultobj;
44787 fail:
44788 {
44789 if (temp3)
44790 delete arg3;
44791 }
44792 return NULL;
44793 }
44794
44795
44796 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44797 PyObject *resultobj = 0;
44798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44799 size_t arg2 ;
44800 wxString result;
44801 void *argp1 = 0 ;
44802 int res1 = 0 ;
44803 size_t val2 ;
44804 int ecode2 = 0 ;
44805 PyObject * obj0 = 0 ;
44806 PyObject * obj1 = 0 ;
44807 char * kwnames[] = {
44808 (char *) "self",(char *) "pos", NULL
44809 };
44810
44811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44813 if (!SWIG_IsOK(res1)) {
44814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44815 }
44816 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44817 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44818 if (!SWIG_IsOK(ecode2)) {
44819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44820 }
44821 arg2 = static_cast< size_t >(val2);
44822 {
44823 PyThreadState* __tstate = wxPyBeginAllowThreads();
44824 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44825 wxPyEndAllowThreads(__tstate);
44826 if (PyErr_Occurred()) SWIG_fail;
44827 }
44828 {
44829 #if wxUSE_UNICODE
44830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44831 #else
44832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44833 #endif
44834 }
44835 return resultobj;
44836 fail:
44837 return NULL;
44838 }
44839
44840
44841 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44842 PyObject *resultobj = 0;
44843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44844 wxString *arg2 = 0 ;
44845 wxString *arg3 = 0 ;
44846 int result;
44847 void *argp1 = 0 ;
44848 int res1 = 0 ;
44849 bool temp2 = false ;
44850 bool temp3 = false ;
44851 PyObject * obj0 = 0 ;
44852 PyObject * obj1 = 0 ;
44853 PyObject * obj2 = 0 ;
44854 char * kwnames[] = {
44855 (char *) "self",(char *) "menu",(char *) "item", NULL
44856 };
44857
44858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44860 if (!SWIG_IsOK(res1)) {
44861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44862 }
44863 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44864 {
44865 arg2 = wxString_in_helper(obj1);
44866 if (arg2 == NULL) SWIG_fail;
44867 temp2 = true;
44868 }
44869 {
44870 arg3 = wxString_in_helper(obj2);
44871 if (arg3 == NULL) SWIG_fail;
44872 temp3 = true;
44873 }
44874 {
44875 PyThreadState* __tstate = wxPyBeginAllowThreads();
44876 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44877 wxPyEndAllowThreads(__tstate);
44878 if (PyErr_Occurred()) SWIG_fail;
44879 }
44880 resultobj = SWIG_From_int(static_cast< int >(result));
44881 {
44882 if (temp2)
44883 delete arg2;
44884 }
44885 {
44886 if (temp3)
44887 delete arg3;
44888 }
44889 return resultobj;
44890 fail:
44891 {
44892 if (temp2)
44893 delete arg2;
44894 }
44895 {
44896 if (temp3)
44897 delete arg3;
44898 }
44899 return NULL;
44900 }
44901
44902
44903 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44904 PyObject *resultobj = 0;
44905 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44906 int arg2 ;
44907 wxMenuItem *result = 0 ;
44908 void *argp1 = 0 ;
44909 int res1 = 0 ;
44910 int val2 ;
44911 int ecode2 = 0 ;
44912 PyObject * obj0 = 0 ;
44913 PyObject * obj1 = 0 ;
44914 char * kwnames[] = {
44915 (char *) "self",(char *) "id", NULL
44916 };
44917
44918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44920 if (!SWIG_IsOK(res1)) {
44921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44922 }
44923 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44924 ecode2 = SWIG_AsVal_int(obj1, &val2);
44925 if (!SWIG_IsOK(ecode2)) {
44926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44927 }
44928 arg2 = static_cast< int >(val2);
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44932 wxPyEndAllowThreads(__tstate);
44933 if (PyErr_Occurred()) SWIG_fail;
44934 }
44935 {
44936 resultobj = wxPyMake_wxObject(result, (bool)0);
44937 }
44938 return resultobj;
44939 fail:
44940 return NULL;
44941 }
44942
44943
44944 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44945 PyObject *resultobj = 0;
44946 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44947 wxString *arg2 = 0 ;
44948 int result;
44949 void *argp1 = 0 ;
44950 int res1 = 0 ;
44951 bool temp2 = false ;
44952 PyObject * obj0 = 0 ;
44953 PyObject * obj1 = 0 ;
44954 char * kwnames[] = {
44955 (char *) "self",(char *) "title", NULL
44956 };
44957
44958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44960 if (!SWIG_IsOK(res1)) {
44961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44962 }
44963 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44964 {
44965 arg2 = wxString_in_helper(obj1);
44966 if (arg2 == NULL) SWIG_fail;
44967 temp2 = true;
44968 }
44969 {
44970 PyThreadState* __tstate = wxPyBeginAllowThreads();
44971 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44972 wxPyEndAllowThreads(__tstate);
44973 if (PyErr_Occurred()) SWIG_fail;
44974 }
44975 resultobj = SWIG_From_int(static_cast< int >(result));
44976 {
44977 if (temp2)
44978 delete arg2;
44979 }
44980 return resultobj;
44981 fail:
44982 {
44983 if (temp2)
44984 delete arg2;
44985 }
44986 return NULL;
44987 }
44988
44989
44990 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44991 PyObject *resultobj = 0;
44992 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44993 int arg2 ;
44994 bool arg3 ;
44995 void *argp1 = 0 ;
44996 int res1 = 0 ;
44997 int val2 ;
44998 int ecode2 = 0 ;
44999 bool val3 ;
45000 int ecode3 = 0 ;
45001 PyObject * obj0 = 0 ;
45002 PyObject * obj1 = 0 ;
45003 PyObject * obj2 = 0 ;
45004 char * kwnames[] = {
45005 (char *) "self",(char *) "id",(char *) "enable", NULL
45006 };
45007
45008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45010 if (!SWIG_IsOK(res1)) {
45011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45012 }
45013 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45014 ecode2 = SWIG_AsVal_int(obj1, &val2);
45015 if (!SWIG_IsOK(ecode2)) {
45016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45017 }
45018 arg2 = static_cast< int >(val2);
45019 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45020 if (!SWIG_IsOK(ecode3)) {
45021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45022 }
45023 arg3 = static_cast< bool >(val3);
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 (arg1)->Enable(arg2,arg3);
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 resultobj = SWIG_Py_Void();
45031 return resultobj;
45032 fail:
45033 return NULL;
45034 }
45035
45036
45037 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45038 PyObject *resultobj = 0;
45039 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45040 int arg2 ;
45041 bool arg3 ;
45042 void *argp1 = 0 ;
45043 int res1 = 0 ;
45044 int val2 ;
45045 int ecode2 = 0 ;
45046 bool val3 ;
45047 int ecode3 = 0 ;
45048 PyObject * obj0 = 0 ;
45049 PyObject * obj1 = 0 ;
45050 PyObject * obj2 = 0 ;
45051 char * kwnames[] = {
45052 (char *) "self",(char *) "id",(char *) "check", NULL
45053 };
45054
45055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45057 if (!SWIG_IsOK(res1)) {
45058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45059 }
45060 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45061 ecode2 = SWIG_AsVal_int(obj1, &val2);
45062 if (!SWIG_IsOK(ecode2)) {
45063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45064 }
45065 arg2 = static_cast< int >(val2);
45066 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45067 if (!SWIG_IsOK(ecode3)) {
45068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45069 }
45070 arg3 = static_cast< bool >(val3);
45071 {
45072 PyThreadState* __tstate = wxPyBeginAllowThreads();
45073 (arg1)->Check(arg2,arg3);
45074 wxPyEndAllowThreads(__tstate);
45075 if (PyErr_Occurred()) SWIG_fail;
45076 }
45077 resultobj = SWIG_Py_Void();
45078 return resultobj;
45079 fail:
45080 return NULL;
45081 }
45082
45083
45084 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45085 PyObject *resultobj = 0;
45086 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45087 int arg2 ;
45088 bool result;
45089 void *argp1 = 0 ;
45090 int res1 = 0 ;
45091 int val2 ;
45092 int ecode2 = 0 ;
45093 PyObject * obj0 = 0 ;
45094 PyObject * obj1 = 0 ;
45095 char * kwnames[] = {
45096 (char *) "self",(char *) "id", NULL
45097 };
45098
45099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45101 if (!SWIG_IsOK(res1)) {
45102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45103 }
45104 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45105 ecode2 = SWIG_AsVal_int(obj1, &val2);
45106 if (!SWIG_IsOK(ecode2)) {
45107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45108 }
45109 arg2 = static_cast< int >(val2);
45110 {
45111 PyThreadState* __tstate = wxPyBeginAllowThreads();
45112 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45113 wxPyEndAllowThreads(__tstate);
45114 if (PyErr_Occurred()) SWIG_fail;
45115 }
45116 {
45117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45118 }
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45126 PyObject *resultobj = 0;
45127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45128 int arg2 ;
45129 bool result;
45130 void *argp1 = 0 ;
45131 int res1 = 0 ;
45132 int val2 ;
45133 int ecode2 = 0 ;
45134 PyObject * obj0 = 0 ;
45135 PyObject * obj1 = 0 ;
45136 char * kwnames[] = {
45137 (char *) "self",(char *) "id", NULL
45138 };
45139
45140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45142 if (!SWIG_IsOK(res1)) {
45143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45144 }
45145 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45146 ecode2 = SWIG_AsVal_int(obj1, &val2);
45147 if (!SWIG_IsOK(ecode2)) {
45148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45149 }
45150 arg2 = static_cast< int >(val2);
45151 {
45152 PyThreadState* __tstate = wxPyBeginAllowThreads();
45153 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45154 wxPyEndAllowThreads(__tstate);
45155 if (PyErr_Occurred()) SWIG_fail;
45156 }
45157 {
45158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45159 }
45160 return resultobj;
45161 fail:
45162 return NULL;
45163 }
45164
45165
45166 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45167 PyObject *resultobj = 0;
45168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45169 int arg2 ;
45170 wxString *arg3 = 0 ;
45171 void *argp1 = 0 ;
45172 int res1 = 0 ;
45173 int val2 ;
45174 int ecode2 = 0 ;
45175 bool temp3 = false ;
45176 PyObject * obj0 = 0 ;
45177 PyObject * obj1 = 0 ;
45178 PyObject * obj2 = 0 ;
45179 char * kwnames[] = {
45180 (char *) "self",(char *) "id",(char *) "label", NULL
45181 };
45182
45183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45185 if (!SWIG_IsOK(res1)) {
45186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45187 }
45188 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45189 ecode2 = SWIG_AsVal_int(obj1, &val2);
45190 if (!SWIG_IsOK(ecode2)) {
45191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45192 }
45193 arg2 = static_cast< int >(val2);
45194 {
45195 arg3 = wxString_in_helper(obj2);
45196 if (arg3 == NULL) SWIG_fail;
45197 temp3 = true;
45198 }
45199 {
45200 PyThreadState* __tstate = wxPyBeginAllowThreads();
45201 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45202 wxPyEndAllowThreads(__tstate);
45203 if (PyErr_Occurred()) SWIG_fail;
45204 }
45205 resultobj = SWIG_Py_Void();
45206 {
45207 if (temp3)
45208 delete arg3;
45209 }
45210 return resultobj;
45211 fail:
45212 {
45213 if (temp3)
45214 delete arg3;
45215 }
45216 return NULL;
45217 }
45218
45219
45220 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj = 0;
45222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45223 int arg2 ;
45224 wxString result;
45225 void *argp1 = 0 ;
45226 int res1 = 0 ;
45227 int val2 ;
45228 int ecode2 = 0 ;
45229 PyObject * obj0 = 0 ;
45230 PyObject * obj1 = 0 ;
45231 char * kwnames[] = {
45232 (char *) "self",(char *) "id", NULL
45233 };
45234
45235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45237 if (!SWIG_IsOK(res1)) {
45238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45239 }
45240 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45241 ecode2 = SWIG_AsVal_int(obj1, &val2);
45242 if (!SWIG_IsOK(ecode2)) {
45243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45244 }
45245 arg2 = static_cast< int >(val2);
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 {
45253 #if wxUSE_UNICODE
45254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45255 #else
45256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45257 #endif
45258 }
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45266 PyObject *resultobj = 0;
45267 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45268 int arg2 ;
45269 wxString *arg3 = 0 ;
45270 void *argp1 = 0 ;
45271 int res1 = 0 ;
45272 int val2 ;
45273 int ecode2 = 0 ;
45274 bool temp3 = false ;
45275 PyObject * obj0 = 0 ;
45276 PyObject * obj1 = 0 ;
45277 PyObject * obj2 = 0 ;
45278 char * kwnames[] = {
45279 (char *) "self",(char *) "id",(char *) "helpString", NULL
45280 };
45281
45282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45284 if (!SWIG_IsOK(res1)) {
45285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45286 }
45287 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45288 ecode2 = SWIG_AsVal_int(obj1, &val2);
45289 if (!SWIG_IsOK(ecode2)) {
45290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45291 }
45292 arg2 = static_cast< int >(val2);
45293 {
45294 arg3 = wxString_in_helper(obj2);
45295 if (arg3 == NULL) SWIG_fail;
45296 temp3 = true;
45297 }
45298 {
45299 PyThreadState* __tstate = wxPyBeginAllowThreads();
45300 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45301 wxPyEndAllowThreads(__tstate);
45302 if (PyErr_Occurred()) SWIG_fail;
45303 }
45304 resultobj = SWIG_Py_Void();
45305 {
45306 if (temp3)
45307 delete arg3;
45308 }
45309 return resultobj;
45310 fail:
45311 {
45312 if (temp3)
45313 delete arg3;
45314 }
45315 return NULL;
45316 }
45317
45318
45319 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45320 PyObject *resultobj = 0;
45321 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45322 int arg2 ;
45323 wxString result;
45324 void *argp1 = 0 ;
45325 int res1 = 0 ;
45326 int val2 ;
45327 int ecode2 = 0 ;
45328 PyObject * obj0 = 0 ;
45329 PyObject * obj1 = 0 ;
45330 char * kwnames[] = {
45331 (char *) "self",(char *) "id", NULL
45332 };
45333
45334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45336 if (!SWIG_IsOK(res1)) {
45337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45338 }
45339 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45340 ecode2 = SWIG_AsVal_int(obj1, &val2);
45341 if (!SWIG_IsOK(ecode2)) {
45342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45343 }
45344 arg2 = static_cast< int >(val2);
45345 {
45346 PyThreadState* __tstate = wxPyBeginAllowThreads();
45347 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45348 wxPyEndAllowThreads(__tstate);
45349 if (PyErr_Occurred()) SWIG_fail;
45350 }
45351 {
45352 #if wxUSE_UNICODE
45353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45354 #else
45355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45356 #endif
45357 }
45358 return resultobj;
45359 fail:
45360 return NULL;
45361 }
45362
45363
45364 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45365 PyObject *resultobj = 0;
45366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45367 wxFrame *result = 0 ;
45368 void *argp1 = 0 ;
45369 int res1 = 0 ;
45370 PyObject *swig_obj[1] ;
45371
45372 if (!args) SWIG_fail;
45373 swig_obj[0] = args;
45374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45375 if (!SWIG_IsOK(res1)) {
45376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45377 }
45378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45379 {
45380 PyThreadState* __tstate = wxPyBeginAllowThreads();
45381 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45382 wxPyEndAllowThreads(__tstate);
45383 if (PyErr_Occurred()) SWIG_fail;
45384 }
45385 {
45386 resultobj = wxPyMake_wxObject(result, (bool)0);
45387 }
45388 return resultobj;
45389 fail:
45390 return NULL;
45391 }
45392
45393
45394 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45395 PyObject *resultobj = 0;
45396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45397 bool result;
45398 void *argp1 = 0 ;
45399 int res1 = 0 ;
45400 PyObject *swig_obj[1] ;
45401
45402 if (!args) SWIG_fail;
45403 swig_obj[0] = args;
45404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45405 if (!SWIG_IsOK(res1)) {
45406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45407 }
45408 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45409 {
45410 PyThreadState* __tstate = wxPyBeginAllowThreads();
45411 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45412 wxPyEndAllowThreads(__tstate);
45413 if (PyErr_Occurred()) SWIG_fail;
45414 }
45415 {
45416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45417 }
45418 return resultobj;
45419 fail:
45420 return NULL;
45421 }
45422
45423
45424 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45425 PyObject *resultobj = 0;
45426 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45427 wxFrame *arg2 = (wxFrame *) 0 ;
45428 void *argp1 = 0 ;
45429 int res1 = 0 ;
45430 void *argp2 = 0 ;
45431 int res2 = 0 ;
45432 PyObject * obj0 = 0 ;
45433 PyObject * obj1 = 0 ;
45434 char * kwnames[] = {
45435 (char *) "self",(char *) "frame", NULL
45436 };
45437
45438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45440 if (!SWIG_IsOK(res1)) {
45441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45442 }
45443 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45445 if (!SWIG_IsOK(res2)) {
45446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45447 }
45448 arg2 = reinterpret_cast< wxFrame * >(argp2);
45449 {
45450 PyThreadState* __tstate = wxPyBeginAllowThreads();
45451 (arg1)->Attach(arg2);
45452 wxPyEndAllowThreads(__tstate);
45453 if (PyErr_Occurred()) SWIG_fail;
45454 }
45455 resultobj = SWIG_Py_Void();
45456 return resultobj;
45457 fail:
45458 return NULL;
45459 }
45460
45461
45462 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45463 PyObject *resultobj = 0;
45464 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 PyObject *swig_obj[1] ;
45468
45469 if (!args) SWIG_fail;
45470 swig_obj[0] = args;
45471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45472 if (!SWIG_IsOK(res1)) {
45473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45474 }
45475 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45476 {
45477 PyThreadState* __tstate = wxPyBeginAllowThreads();
45478 (arg1)->Detach();
45479 wxPyEndAllowThreads(__tstate);
45480 if (PyErr_Occurred()) SWIG_fail;
45481 }
45482 resultobj = SWIG_Py_Void();
45483 return resultobj;
45484 fail:
45485 return NULL;
45486 }
45487
45488
45489 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45490 PyObject *resultobj = 0;
45491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45492 void *argp1 = 0 ;
45493 int res1 = 0 ;
45494 PyObject *swig_obj[1] ;
45495
45496 if (!args) SWIG_fail;
45497 swig_obj[0] = args;
45498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45499 if (!SWIG_IsOK(res1)) {
45500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45501 }
45502 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45503 {
45504 PyThreadState* __tstate = wxPyBeginAllowThreads();
45505 (arg1)->UpdateMenus();
45506 wxPyEndAllowThreads(__tstate);
45507 if (PyErr_Occurred()) SWIG_fail;
45508 }
45509 resultobj = SWIG_Py_Void();
45510 return resultobj;
45511 fail:
45512 return NULL;
45513 }
45514
45515
45516 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45517 PyObject *resultobj = 0;
45518 bool arg1 ;
45519 bool val1 ;
45520 int ecode1 = 0 ;
45521 PyObject * obj0 = 0 ;
45522 char * kwnames[] = {
45523 (char *) "enable", NULL
45524 };
45525
45526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45527 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45528 if (!SWIG_IsOK(ecode1)) {
45529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45530 }
45531 arg1 = static_cast< bool >(val1);
45532 {
45533 PyThreadState* __tstate = wxPyBeginAllowThreads();
45534 wxMenuBar::SetAutoWindowMenu(arg1);
45535 wxPyEndAllowThreads(__tstate);
45536 if (PyErr_Occurred()) SWIG_fail;
45537 }
45538 resultobj = SWIG_Py_Void();
45539 return resultobj;
45540 fail:
45541 return NULL;
45542 }
45543
45544
45545 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45546 PyObject *resultobj = 0;
45547 bool result;
45548
45549 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45550 {
45551 PyThreadState* __tstate = wxPyBeginAllowThreads();
45552 result = (bool)wxMenuBar::GetAutoWindowMenu();
45553 wxPyEndAllowThreads(__tstate);
45554 if (PyErr_Occurred()) SWIG_fail;
45555 }
45556 {
45557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45558 }
45559 return resultobj;
45560 fail:
45561 return NULL;
45562 }
45563
45564
45565 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45566 PyObject *obj;
45567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45568 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45569 return SWIG_Py_Void();
45570 }
45571
45572 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45573 return SWIG_Python_InitShadowInstance(args);
45574 }
45575
45576 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45577 PyObject *resultobj = 0;
45578 wxMenu *arg1 = (wxMenu *) NULL ;
45579 int arg2 = (int) wxID_ANY ;
45580 wxString const &arg3_defvalue = wxPyEmptyString ;
45581 wxString *arg3 = (wxString *) &arg3_defvalue ;
45582 wxString const &arg4_defvalue = wxPyEmptyString ;
45583 wxString *arg4 = (wxString *) &arg4_defvalue ;
45584 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45585 wxMenu *arg6 = (wxMenu *) NULL ;
45586 wxMenuItem *result = 0 ;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 int val2 ;
45590 int ecode2 = 0 ;
45591 bool temp3 = false ;
45592 bool temp4 = false ;
45593 int val5 ;
45594 int ecode5 = 0 ;
45595 void *argp6 = 0 ;
45596 int res6 = 0 ;
45597 PyObject * obj0 = 0 ;
45598 PyObject * obj1 = 0 ;
45599 PyObject * obj2 = 0 ;
45600 PyObject * obj3 = 0 ;
45601 PyObject * obj4 = 0 ;
45602 PyObject * obj5 = 0 ;
45603 char * kwnames[] = {
45604 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45605 };
45606
45607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45608 if (obj0) {
45609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45610 if (!SWIG_IsOK(res1)) {
45611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45612 }
45613 arg1 = reinterpret_cast< wxMenu * >(argp1);
45614 }
45615 if (obj1) {
45616 ecode2 = SWIG_AsVal_int(obj1, &val2);
45617 if (!SWIG_IsOK(ecode2)) {
45618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45619 }
45620 arg2 = static_cast< int >(val2);
45621 }
45622 if (obj2) {
45623 {
45624 arg3 = wxString_in_helper(obj2);
45625 if (arg3 == NULL) SWIG_fail;
45626 temp3 = true;
45627 }
45628 }
45629 if (obj3) {
45630 {
45631 arg4 = wxString_in_helper(obj3);
45632 if (arg4 == NULL) SWIG_fail;
45633 temp4 = true;
45634 }
45635 }
45636 if (obj4) {
45637 ecode5 = SWIG_AsVal_int(obj4, &val5);
45638 if (!SWIG_IsOK(ecode5)) {
45639 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45640 }
45641 arg5 = static_cast< wxItemKind >(val5);
45642 }
45643 if (obj5) {
45644 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45645 if (!SWIG_IsOK(res6)) {
45646 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45647 }
45648 arg6 = reinterpret_cast< wxMenu * >(argp6);
45649 }
45650 {
45651 PyThreadState* __tstate = wxPyBeginAllowThreads();
45652 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45653 wxPyEndAllowThreads(__tstate);
45654 if (PyErr_Occurred()) SWIG_fail;
45655 }
45656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45657 {
45658 if (temp3)
45659 delete arg3;
45660 }
45661 {
45662 if (temp4)
45663 delete arg4;
45664 }
45665 return resultobj;
45666 fail:
45667 {
45668 if (temp3)
45669 delete arg3;
45670 }
45671 {
45672 if (temp4)
45673 delete arg4;
45674 }
45675 return NULL;
45676 }
45677
45678
45679 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45680 PyObject *resultobj = 0;
45681 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45682 void *argp1 = 0 ;
45683 int res1 = 0 ;
45684 PyObject *swig_obj[1] ;
45685
45686 if (!args) SWIG_fail;
45687 swig_obj[0] = args;
45688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45689 if (!SWIG_IsOK(res1)) {
45690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45691 }
45692 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45693 {
45694 PyThreadState* __tstate = wxPyBeginAllowThreads();
45695 delete arg1;
45696
45697 wxPyEndAllowThreads(__tstate);
45698 if (PyErr_Occurred()) SWIG_fail;
45699 }
45700 resultobj = SWIG_Py_Void();
45701 return resultobj;
45702 fail:
45703 return NULL;
45704 }
45705
45706
45707 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45708 PyObject *resultobj = 0;
45709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45710 wxMenu *result = 0 ;
45711 void *argp1 = 0 ;
45712 int res1 = 0 ;
45713 PyObject *swig_obj[1] ;
45714
45715 if (!args) SWIG_fail;
45716 swig_obj[0] = args;
45717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45718 if (!SWIG_IsOK(res1)) {
45719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45720 }
45721 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45722 {
45723 PyThreadState* __tstate = wxPyBeginAllowThreads();
45724 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45725 wxPyEndAllowThreads(__tstate);
45726 if (PyErr_Occurred()) SWIG_fail;
45727 }
45728 {
45729 resultobj = wxPyMake_wxObject(result, 0);
45730 }
45731 return resultobj;
45732 fail:
45733 return NULL;
45734 }
45735
45736
45737 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45738 PyObject *resultobj = 0;
45739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45740 wxMenu *arg2 = (wxMenu *) 0 ;
45741 void *argp1 = 0 ;
45742 int res1 = 0 ;
45743 void *argp2 = 0 ;
45744 int res2 = 0 ;
45745 PyObject * obj0 = 0 ;
45746 PyObject * obj1 = 0 ;
45747 char * kwnames[] = {
45748 (char *) "self",(char *) "menu", NULL
45749 };
45750
45751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45753 if (!SWIG_IsOK(res1)) {
45754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45755 }
45756 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45758 if (!SWIG_IsOK(res2)) {
45759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45760 }
45761 arg2 = reinterpret_cast< wxMenu * >(argp2);
45762 {
45763 PyThreadState* __tstate = wxPyBeginAllowThreads();
45764 (arg1)->SetMenu(arg2);
45765 wxPyEndAllowThreads(__tstate);
45766 if (PyErr_Occurred()) SWIG_fail;
45767 }
45768 resultobj = SWIG_Py_Void();
45769 return resultobj;
45770 fail:
45771 return NULL;
45772 }
45773
45774
45775 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45776 PyObject *resultobj = 0;
45777 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45778 int arg2 ;
45779 void *argp1 = 0 ;
45780 int res1 = 0 ;
45781 int val2 ;
45782 int ecode2 = 0 ;
45783 PyObject * obj0 = 0 ;
45784 PyObject * obj1 = 0 ;
45785 char * kwnames[] = {
45786 (char *) "self",(char *) "id", NULL
45787 };
45788
45789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45791 if (!SWIG_IsOK(res1)) {
45792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45793 }
45794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45795 ecode2 = SWIG_AsVal_int(obj1, &val2);
45796 if (!SWIG_IsOK(ecode2)) {
45797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45798 }
45799 arg2 = static_cast< int >(val2);
45800 {
45801 PyThreadState* __tstate = wxPyBeginAllowThreads();
45802 (arg1)->SetId(arg2);
45803 wxPyEndAllowThreads(__tstate);
45804 if (PyErr_Occurred()) SWIG_fail;
45805 }
45806 resultobj = SWIG_Py_Void();
45807 return resultobj;
45808 fail:
45809 return NULL;
45810 }
45811
45812
45813 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45814 PyObject *resultobj = 0;
45815 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45816 int result;
45817 void *argp1 = 0 ;
45818 int res1 = 0 ;
45819 PyObject *swig_obj[1] ;
45820
45821 if (!args) SWIG_fail;
45822 swig_obj[0] = args;
45823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45824 if (!SWIG_IsOK(res1)) {
45825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45826 }
45827 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45828 {
45829 PyThreadState* __tstate = wxPyBeginAllowThreads();
45830 result = (int)((wxMenuItem const *)arg1)->GetId();
45831 wxPyEndAllowThreads(__tstate);
45832 if (PyErr_Occurred()) SWIG_fail;
45833 }
45834 resultobj = SWIG_From_int(static_cast< int >(result));
45835 return resultobj;
45836 fail:
45837 return NULL;
45838 }
45839
45840
45841 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45842 PyObject *resultobj = 0;
45843 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45844 bool result;
45845 void *argp1 = 0 ;
45846 int res1 = 0 ;
45847 PyObject *swig_obj[1] ;
45848
45849 if (!args) SWIG_fail;
45850 swig_obj[0] = args;
45851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45852 if (!SWIG_IsOK(res1)) {
45853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45854 }
45855 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45856 {
45857 PyThreadState* __tstate = wxPyBeginAllowThreads();
45858 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45859 wxPyEndAllowThreads(__tstate);
45860 if (PyErr_Occurred()) SWIG_fail;
45861 }
45862 {
45863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45864 }
45865 return resultobj;
45866 fail:
45867 return NULL;
45868 }
45869
45870
45871 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45872 PyObject *resultobj = 0;
45873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45874 wxString *arg2 = 0 ;
45875 void *argp1 = 0 ;
45876 int res1 = 0 ;
45877 bool temp2 = false ;
45878 PyObject * obj0 = 0 ;
45879 PyObject * obj1 = 0 ;
45880 char * kwnames[] = {
45881 (char *) "self",(char *) "str", NULL
45882 };
45883
45884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45886 if (!SWIG_IsOK(res1)) {
45887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45888 }
45889 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45890 {
45891 arg2 = wxString_in_helper(obj1);
45892 if (arg2 == NULL) SWIG_fail;
45893 temp2 = true;
45894 }
45895 {
45896 PyThreadState* __tstate = wxPyBeginAllowThreads();
45897 (arg1)->SetText((wxString const &)*arg2);
45898 wxPyEndAllowThreads(__tstate);
45899 if (PyErr_Occurred()) SWIG_fail;
45900 }
45901 resultobj = SWIG_Py_Void();
45902 {
45903 if (temp2)
45904 delete arg2;
45905 }
45906 return resultobj;
45907 fail:
45908 {
45909 if (temp2)
45910 delete arg2;
45911 }
45912 return NULL;
45913 }
45914
45915
45916 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45917 PyObject *resultobj = 0;
45918 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45919 wxString result;
45920 void *argp1 = 0 ;
45921 int res1 = 0 ;
45922 PyObject *swig_obj[1] ;
45923
45924 if (!args) SWIG_fail;
45925 swig_obj[0] = args;
45926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45927 if (!SWIG_IsOK(res1)) {
45928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45929 }
45930 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45931 {
45932 PyThreadState* __tstate = wxPyBeginAllowThreads();
45933 result = ((wxMenuItem const *)arg1)->GetLabel();
45934 wxPyEndAllowThreads(__tstate);
45935 if (PyErr_Occurred()) SWIG_fail;
45936 }
45937 {
45938 #if wxUSE_UNICODE
45939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45940 #else
45941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45942 #endif
45943 }
45944 return resultobj;
45945 fail:
45946 return NULL;
45947 }
45948
45949
45950 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45951 PyObject *resultobj = 0;
45952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45953 wxString *result = 0 ;
45954 void *argp1 = 0 ;
45955 int res1 = 0 ;
45956 PyObject *swig_obj[1] ;
45957
45958 if (!args) SWIG_fail;
45959 swig_obj[0] = args;
45960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45961 if (!SWIG_IsOK(res1)) {
45962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45963 }
45964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45965 {
45966 PyThreadState* __tstate = wxPyBeginAllowThreads();
45967 {
45968 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45969 result = (wxString *) &_result_ref;
45970 }
45971 wxPyEndAllowThreads(__tstate);
45972 if (PyErr_Occurred()) SWIG_fail;
45973 }
45974 {
45975 #if wxUSE_UNICODE
45976 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45977 #else
45978 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45979 #endif
45980 }
45981 return resultobj;
45982 fail:
45983 return NULL;
45984 }
45985
45986
45987 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45988 PyObject *resultobj = 0;
45989 wxString *arg1 = 0 ;
45990 wxString result;
45991 bool temp1 = false ;
45992 PyObject * obj0 = 0 ;
45993 char * kwnames[] = {
45994 (char *) "text", NULL
45995 };
45996
45997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
45998 {
45999 arg1 = wxString_in_helper(obj0);
46000 if (arg1 == NULL) SWIG_fail;
46001 temp1 = true;
46002 }
46003 {
46004 PyThreadState* __tstate = wxPyBeginAllowThreads();
46005 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46006 wxPyEndAllowThreads(__tstate);
46007 if (PyErr_Occurred()) SWIG_fail;
46008 }
46009 {
46010 #if wxUSE_UNICODE
46011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46012 #else
46013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46014 #endif
46015 }
46016 {
46017 if (temp1)
46018 delete arg1;
46019 }
46020 return resultobj;
46021 fail:
46022 {
46023 if (temp1)
46024 delete arg1;
46025 }
46026 return NULL;
46027 }
46028
46029
46030 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46031 PyObject *resultobj = 0;
46032 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46033 wxItemKind result;
46034 void *argp1 = 0 ;
46035 int res1 = 0 ;
46036 PyObject *swig_obj[1] ;
46037
46038 if (!args) SWIG_fail;
46039 swig_obj[0] = args;
46040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46041 if (!SWIG_IsOK(res1)) {
46042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46043 }
46044 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46045 {
46046 PyThreadState* __tstate = wxPyBeginAllowThreads();
46047 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46048 wxPyEndAllowThreads(__tstate);
46049 if (PyErr_Occurred()) SWIG_fail;
46050 }
46051 resultobj = SWIG_From_int(static_cast< int >(result));
46052 return resultobj;
46053 fail:
46054 return NULL;
46055 }
46056
46057
46058 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46059 PyObject *resultobj = 0;
46060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46061 wxItemKind arg2 ;
46062 void *argp1 = 0 ;
46063 int res1 = 0 ;
46064 int val2 ;
46065 int ecode2 = 0 ;
46066 PyObject * obj0 = 0 ;
46067 PyObject * obj1 = 0 ;
46068 char * kwnames[] = {
46069 (char *) "self",(char *) "kind", NULL
46070 };
46071
46072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46074 if (!SWIG_IsOK(res1)) {
46075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46076 }
46077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46078 ecode2 = SWIG_AsVal_int(obj1, &val2);
46079 if (!SWIG_IsOK(ecode2)) {
46080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46081 }
46082 arg2 = static_cast< wxItemKind >(val2);
46083 {
46084 PyThreadState* __tstate = wxPyBeginAllowThreads();
46085 (arg1)->SetKind(arg2);
46086 wxPyEndAllowThreads(__tstate);
46087 if (PyErr_Occurred()) SWIG_fail;
46088 }
46089 resultobj = SWIG_Py_Void();
46090 return resultobj;
46091 fail:
46092 return NULL;
46093 }
46094
46095
46096 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46097 PyObject *resultobj = 0;
46098 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46099 bool arg2 ;
46100 void *argp1 = 0 ;
46101 int res1 = 0 ;
46102 bool val2 ;
46103 int ecode2 = 0 ;
46104 PyObject * obj0 = 0 ;
46105 PyObject * obj1 = 0 ;
46106 char * kwnames[] = {
46107 (char *) "self",(char *) "checkable", NULL
46108 };
46109
46110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46112 if (!SWIG_IsOK(res1)) {
46113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46114 }
46115 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46117 if (!SWIG_IsOK(ecode2)) {
46118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46119 }
46120 arg2 = static_cast< bool >(val2);
46121 {
46122 PyThreadState* __tstate = wxPyBeginAllowThreads();
46123 (arg1)->SetCheckable(arg2);
46124 wxPyEndAllowThreads(__tstate);
46125 if (PyErr_Occurred()) SWIG_fail;
46126 }
46127 resultobj = SWIG_Py_Void();
46128 return resultobj;
46129 fail:
46130 return NULL;
46131 }
46132
46133
46134 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46135 PyObject *resultobj = 0;
46136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46137 bool result;
46138 void *argp1 = 0 ;
46139 int res1 = 0 ;
46140 PyObject *swig_obj[1] ;
46141
46142 if (!args) SWIG_fail;
46143 swig_obj[0] = args;
46144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46145 if (!SWIG_IsOK(res1)) {
46146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46147 }
46148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46149 {
46150 PyThreadState* __tstate = wxPyBeginAllowThreads();
46151 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46152 wxPyEndAllowThreads(__tstate);
46153 if (PyErr_Occurred()) SWIG_fail;
46154 }
46155 {
46156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46157 }
46158 return resultobj;
46159 fail:
46160 return NULL;
46161 }
46162
46163
46164 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46165 PyObject *resultobj = 0;
46166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46167 bool result;
46168 void *argp1 = 0 ;
46169 int res1 = 0 ;
46170 PyObject *swig_obj[1] ;
46171
46172 if (!args) SWIG_fail;
46173 swig_obj[0] = args;
46174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46175 if (!SWIG_IsOK(res1)) {
46176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46177 }
46178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46179 {
46180 PyThreadState* __tstate = wxPyBeginAllowThreads();
46181 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46182 wxPyEndAllowThreads(__tstate);
46183 if (PyErr_Occurred()) SWIG_fail;
46184 }
46185 {
46186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46187 }
46188 return resultobj;
46189 fail:
46190 return NULL;
46191 }
46192
46193
46194 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46195 PyObject *resultobj = 0;
46196 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46197 wxMenu *arg2 = (wxMenu *) 0 ;
46198 void *argp1 = 0 ;
46199 int res1 = 0 ;
46200 void *argp2 = 0 ;
46201 int res2 = 0 ;
46202 PyObject * obj0 = 0 ;
46203 PyObject * obj1 = 0 ;
46204 char * kwnames[] = {
46205 (char *) "self",(char *) "menu", NULL
46206 };
46207
46208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46210 if (!SWIG_IsOK(res1)) {
46211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46212 }
46213 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46214 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46215 if (!SWIG_IsOK(res2)) {
46216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46217 }
46218 arg2 = reinterpret_cast< wxMenu * >(argp2);
46219 {
46220 PyThreadState* __tstate = wxPyBeginAllowThreads();
46221 (arg1)->SetSubMenu(arg2);
46222 wxPyEndAllowThreads(__tstate);
46223 if (PyErr_Occurred()) SWIG_fail;
46224 }
46225 resultobj = SWIG_Py_Void();
46226 return resultobj;
46227 fail:
46228 return NULL;
46229 }
46230
46231
46232 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46233 PyObject *resultobj = 0;
46234 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46235 wxMenu *result = 0 ;
46236 void *argp1 = 0 ;
46237 int res1 = 0 ;
46238 PyObject *swig_obj[1] ;
46239
46240 if (!args) SWIG_fail;
46241 swig_obj[0] = args;
46242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46243 if (!SWIG_IsOK(res1)) {
46244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46245 }
46246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46247 {
46248 PyThreadState* __tstate = wxPyBeginAllowThreads();
46249 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46250 wxPyEndAllowThreads(__tstate);
46251 if (PyErr_Occurred()) SWIG_fail;
46252 }
46253 {
46254 resultobj = wxPyMake_wxObject(result, 0);
46255 }
46256 return resultobj;
46257 fail:
46258 return NULL;
46259 }
46260
46261
46262 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46263 PyObject *resultobj = 0;
46264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46265 bool arg2 = (bool) true ;
46266 void *argp1 = 0 ;
46267 int res1 = 0 ;
46268 bool val2 ;
46269 int ecode2 = 0 ;
46270 PyObject * obj0 = 0 ;
46271 PyObject * obj1 = 0 ;
46272 char * kwnames[] = {
46273 (char *) "self",(char *) "enable", NULL
46274 };
46275
46276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46278 if (!SWIG_IsOK(res1)) {
46279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46280 }
46281 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46282 if (obj1) {
46283 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46284 if (!SWIG_IsOK(ecode2)) {
46285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46286 }
46287 arg2 = static_cast< bool >(val2);
46288 }
46289 {
46290 PyThreadState* __tstate = wxPyBeginAllowThreads();
46291 (arg1)->Enable(arg2);
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_Py_Void();
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46303 PyObject *resultobj = 0;
46304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46305 bool result;
46306 void *argp1 = 0 ;
46307 int res1 = 0 ;
46308 PyObject *swig_obj[1] ;
46309
46310 if (!args) SWIG_fail;
46311 swig_obj[0] = args;
46312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46313 if (!SWIG_IsOK(res1)) {
46314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46315 }
46316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46317 {
46318 PyThreadState* __tstate = wxPyBeginAllowThreads();
46319 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 {
46324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46325 }
46326 return resultobj;
46327 fail:
46328 return NULL;
46329 }
46330
46331
46332 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46333 PyObject *resultobj = 0;
46334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46335 bool arg2 = (bool) true ;
46336 void *argp1 = 0 ;
46337 int res1 = 0 ;
46338 bool val2 ;
46339 int ecode2 = 0 ;
46340 PyObject * obj0 = 0 ;
46341 PyObject * obj1 = 0 ;
46342 char * kwnames[] = {
46343 (char *) "self",(char *) "check", NULL
46344 };
46345
46346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46348 if (!SWIG_IsOK(res1)) {
46349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46350 }
46351 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46352 if (obj1) {
46353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46354 if (!SWIG_IsOK(ecode2)) {
46355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46356 }
46357 arg2 = static_cast< bool >(val2);
46358 }
46359 {
46360 PyThreadState* __tstate = wxPyBeginAllowThreads();
46361 (arg1)->Check(arg2);
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 resultobj = SWIG_Py_Void();
46366 return resultobj;
46367 fail:
46368 return NULL;
46369 }
46370
46371
46372 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46373 PyObject *resultobj = 0;
46374 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46375 bool result;
46376 void *argp1 = 0 ;
46377 int res1 = 0 ;
46378 PyObject *swig_obj[1] ;
46379
46380 if (!args) SWIG_fail;
46381 swig_obj[0] = args;
46382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46383 if (!SWIG_IsOK(res1)) {
46384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46385 }
46386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46387 {
46388 PyThreadState* __tstate = wxPyBeginAllowThreads();
46389 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46390 wxPyEndAllowThreads(__tstate);
46391 if (PyErr_Occurred()) SWIG_fail;
46392 }
46393 {
46394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46395 }
46396 return resultobj;
46397 fail:
46398 return NULL;
46399 }
46400
46401
46402 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46403 PyObject *resultobj = 0;
46404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46405 void *argp1 = 0 ;
46406 int res1 = 0 ;
46407 PyObject *swig_obj[1] ;
46408
46409 if (!args) SWIG_fail;
46410 swig_obj[0] = args;
46411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46412 if (!SWIG_IsOK(res1)) {
46413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46414 }
46415 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46416 {
46417 PyThreadState* __tstate = wxPyBeginAllowThreads();
46418 (arg1)->Toggle();
46419 wxPyEndAllowThreads(__tstate);
46420 if (PyErr_Occurred()) SWIG_fail;
46421 }
46422 resultobj = SWIG_Py_Void();
46423 return resultobj;
46424 fail:
46425 return NULL;
46426 }
46427
46428
46429 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46430 PyObject *resultobj = 0;
46431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46432 wxString *arg2 = 0 ;
46433 void *argp1 = 0 ;
46434 int res1 = 0 ;
46435 bool temp2 = false ;
46436 PyObject * obj0 = 0 ;
46437 PyObject * obj1 = 0 ;
46438 char * kwnames[] = {
46439 (char *) "self",(char *) "str", NULL
46440 };
46441
46442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46444 if (!SWIG_IsOK(res1)) {
46445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46446 }
46447 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46448 {
46449 arg2 = wxString_in_helper(obj1);
46450 if (arg2 == NULL) SWIG_fail;
46451 temp2 = true;
46452 }
46453 {
46454 PyThreadState* __tstate = wxPyBeginAllowThreads();
46455 (arg1)->SetHelp((wxString const &)*arg2);
46456 wxPyEndAllowThreads(__tstate);
46457 if (PyErr_Occurred()) SWIG_fail;
46458 }
46459 resultobj = SWIG_Py_Void();
46460 {
46461 if (temp2)
46462 delete arg2;
46463 }
46464 return resultobj;
46465 fail:
46466 {
46467 if (temp2)
46468 delete arg2;
46469 }
46470 return NULL;
46471 }
46472
46473
46474 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46475 PyObject *resultobj = 0;
46476 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46477 wxString *result = 0 ;
46478 void *argp1 = 0 ;
46479 int res1 = 0 ;
46480 PyObject *swig_obj[1] ;
46481
46482 if (!args) SWIG_fail;
46483 swig_obj[0] = args;
46484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46485 if (!SWIG_IsOK(res1)) {
46486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46487 }
46488 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46489 {
46490 PyThreadState* __tstate = wxPyBeginAllowThreads();
46491 {
46492 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46493 result = (wxString *) &_result_ref;
46494 }
46495 wxPyEndAllowThreads(__tstate);
46496 if (PyErr_Occurred()) SWIG_fail;
46497 }
46498 {
46499 #if wxUSE_UNICODE
46500 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46501 #else
46502 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46503 #endif
46504 }
46505 return resultobj;
46506 fail:
46507 return NULL;
46508 }
46509
46510
46511 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46512 PyObject *resultobj = 0;
46513 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46514 wxAcceleratorEntry *result = 0 ;
46515 void *argp1 = 0 ;
46516 int res1 = 0 ;
46517 PyObject *swig_obj[1] ;
46518
46519 if (!args) SWIG_fail;
46520 swig_obj[0] = args;
46521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46522 if (!SWIG_IsOK(res1)) {
46523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46524 }
46525 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46526 {
46527 PyThreadState* __tstate = wxPyBeginAllowThreads();
46528 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46529 wxPyEndAllowThreads(__tstate);
46530 if (PyErr_Occurred()) SWIG_fail;
46531 }
46532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46533 return resultobj;
46534 fail:
46535 return NULL;
46536 }
46537
46538
46539 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46540 PyObject *resultobj = 0;
46541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46542 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46543 void *argp1 = 0 ;
46544 int res1 = 0 ;
46545 void *argp2 = 0 ;
46546 int res2 = 0 ;
46547 PyObject * obj0 = 0 ;
46548 PyObject * obj1 = 0 ;
46549 char * kwnames[] = {
46550 (char *) "self",(char *) "accel", NULL
46551 };
46552
46553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46555 if (!SWIG_IsOK(res1)) {
46556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46557 }
46558 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46559 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46560 if (!SWIG_IsOK(res2)) {
46561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46562 }
46563 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46564 {
46565 PyThreadState* __tstate = wxPyBeginAllowThreads();
46566 (arg1)->SetAccel(arg2);
46567 wxPyEndAllowThreads(__tstate);
46568 if (PyErr_Occurred()) SWIG_fail;
46569 }
46570 resultobj = SWIG_Py_Void();
46571 return resultobj;
46572 fail:
46573 return NULL;
46574 }
46575
46576
46577 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46578 PyObject *resultobj = 0;
46579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46580 wxBitmap *arg2 = 0 ;
46581 void *argp1 = 0 ;
46582 int res1 = 0 ;
46583 void *argp2 = 0 ;
46584 int res2 = 0 ;
46585 PyObject * obj0 = 0 ;
46586 PyObject * obj1 = 0 ;
46587 char * kwnames[] = {
46588 (char *) "self",(char *) "bitmap", NULL
46589 };
46590
46591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46593 if (!SWIG_IsOK(res1)) {
46594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46595 }
46596 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46598 if (!SWIG_IsOK(res2)) {
46599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46600 }
46601 if (!argp2) {
46602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46603 }
46604 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46605 {
46606 PyThreadState* __tstate = wxPyBeginAllowThreads();
46607 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46608 wxPyEndAllowThreads(__tstate);
46609 if (PyErr_Occurred()) SWIG_fail;
46610 }
46611 resultobj = SWIG_Py_Void();
46612 return resultobj;
46613 fail:
46614 return NULL;
46615 }
46616
46617
46618 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46619 PyObject *resultobj = 0;
46620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46621 wxBitmap *result = 0 ;
46622 void *argp1 = 0 ;
46623 int res1 = 0 ;
46624 PyObject *swig_obj[1] ;
46625
46626 if (!args) SWIG_fail;
46627 swig_obj[0] = args;
46628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46629 if (!SWIG_IsOK(res1)) {
46630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46631 }
46632 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46633 {
46634 PyThreadState* __tstate = wxPyBeginAllowThreads();
46635 {
46636 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46637 result = (wxBitmap *) &_result_ref;
46638 }
46639 wxPyEndAllowThreads(__tstate);
46640 if (PyErr_Occurred()) SWIG_fail;
46641 }
46642 {
46643 wxBitmap* resultptr = new wxBitmap(*result);
46644 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46645 }
46646 return resultobj;
46647 fail:
46648 return NULL;
46649 }
46650
46651
46652 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46653 PyObject *resultobj = 0;
46654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46655 wxFont *arg2 = 0 ;
46656 void *argp1 = 0 ;
46657 int res1 = 0 ;
46658 void *argp2 = 0 ;
46659 int res2 = 0 ;
46660 PyObject * obj0 = 0 ;
46661 PyObject * obj1 = 0 ;
46662 char * kwnames[] = {
46663 (char *) "self",(char *) "font", NULL
46664 };
46665
46666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46668 if (!SWIG_IsOK(res1)) {
46669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46670 }
46671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46672 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46673 if (!SWIG_IsOK(res2)) {
46674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46675 }
46676 if (!argp2) {
46677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46678 }
46679 arg2 = reinterpret_cast< wxFont * >(argp2);
46680 {
46681 PyThreadState* __tstate = wxPyBeginAllowThreads();
46682 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46683 wxPyEndAllowThreads(__tstate);
46684 if (PyErr_Occurred()) SWIG_fail;
46685 }
46686 resultobj = SWIG_Py_Void();
46687 return resultobj;
46688 fail:
46689 return NULL;
46690 }
46691
46692
46693 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46694 PyObject *resultobj = 0;
46695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46696 wxFont result;
46697 void *argp1 = 0 ;
46698 int res1 = 0 ;
46699 PyObject *swig_obj[1] ;
46700
46701 if (!args) SWIG_fail;
46702 swig_obj[0] = args;
46703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46704 if (!SWIG_IsOK(res1)) {
46705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46706 }
46707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46708 {
46709 PyThreadState* __tstate = wxPyBeginAllowThreads();
46710 result = wxMenuItem_GetFont(arg1);
46711 wxPyEndAllowThreads(__tstate);
46712 if (PyErr_Occurred()) SWIG_fail;
46713 }
46714 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46715 return resultobj;
46716 fail:
46717 return NULL;
46718 }
46719
46720
46721 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46722 PyObject *resultobj = 0;
46723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46724 wxColour *arg2 = 0 ;
46725 void *argp1 = 0 ;
46726 int res1 = 0 ;
46727 wxColour temp2 ;
46728 PyObject * obj0 = 0 ;
46729 PyObject * obj1 = 0 ;
46730 char * kwnames[] = {
46731 (char *) "self",(char *) "colText", NULL
46732 };
46733
46734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46736 if (!SWIG_IsOK(res1)) {
46737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46738 }
46739 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46740 {
46741 arg2 = &temp2;
46742 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46743 }
46744 {
46745 PyThreadState* __tstate = wxPyBeginAllowThreads();
46746 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46747 wxPyEndAllowThreads(__tstate);
46748 if (PyErr_Occurred()) SWIG_fail;
46749 }
46750 resultobj = SWIG_Py_Void();
46751 return resultobj;
46752 fail:
46753 return NULL;
46754 }
46755
46756
46757 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46758 PyObject *resultobj = 0;
46759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46760 wxColour result;
46761 void *argp1 = 0 ;
46762 int res1 = 0 ;
46763 PyObject *swig_obj[1] ;
46764
46765 if (!args) SWIG_fail;
46766 swig_obj[0] = args;
46767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46768 if (!SWIG_IsOK(res1)) {
46769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46770 }
46771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 result = wxMenuItem_GetTextColour(arg1);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46788 wxColour *arg2 = 0 ;
46789 void *argp1 = 0 ;
46790 int res1 = 0 ;
46791 wxColour temp2 ;
46792 PyObject * obj0 = 0 ;
46793 PyObject * obj1 = 0 ;
46794 char * kwnames[] = {
46795 (char *) "self",(char *) "colBack", NULL
46796 };
46797
46798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46800 if (!SWIG_IsOK(res1)) {
46801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46802 }
46803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46804 {
46805 arg2 = &temp2;
46806 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46807 }
46808 {
46809 PyThreadState* __tstate = wxPyBeginAllowThreads();
46810 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46811 wxPyEndAllowThreads(__tstate);
46812 if (PyErr_Occurred()) SWIG_fail;
46813 }
46814 resultobj = SWIG_Py_Void();
46815 return resultobj;
46816 fail:
46817 return NULL;
46818 }
46819
46820
46821 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46822 PyObject *resultobj = 0;
46823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46824 wxColour result;
46825 void *argp1 = 0 ;
46826 int res1 = 0 ;
46827 PyObject *swig_obj[1] ;
46828
46829 if (!args) SWIG_fail;
46830 swig_obj[0] = args;
46831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46832 if (!SWIG_IsOK(res1)) {
46833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46834 }
46835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46836 {
46837 PyThreadState* __tstate = wxPyBeginAllowThreads();
46838 result = wxMenuItem_GetBackgroundColour(arg1);
46839 wxPyEndAllowThreads(__tstate);
46840 if (PyErr_Occurred()) SWIG_fail;
46841 }
46842 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46843 return resultobj;
46844 fail:
46845 return NULL;
46846 }
46847
46848
46849 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46850 PyObject *resultobj = 0;
46851 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46852 wxBitmap *arg2 = 0 ;
46853 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46854 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46855 void *argp1 = 0 ;
46856 int res1 = 0 ;
46857 void *argp2 = 0 ;
46858 int res2 = 0 ;
46859 void *argp3 = 0 ;
46860 int res3 = 0 ;
46861 PyObject * obj0 = 0 ;
46862 PyObject * obj1 = 0 ;
46863 PyObject * obj2 = 0 ;
46864 char * kwnames[] = {
46865 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46866 };
46867
46868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46870 if (!SWIG_IsOK(res1)) {
46871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46872 }
46873 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46874 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46875 if (!SWIG_IsOK(res2)) {
46876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46877 }
46878 if (!argp2) {
46879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46880 }
46881 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46882 if (obj2) {
46883 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46884 if (!SWIG_IsOK(res3)) {
46885 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46886 }
46887 if (!argp3) {
46888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46889 }
46890 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46891 }
46892 {
46893 PyThreadState* __tstate = wxPyBeginAllowThreads();
46894 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46895 wxPyEndAllowThreads(__tstate);
46896 if (PyErr_Occurred()) SWIG_fail;
46897 }
46898 resultobj = SWIG_Py_Void();
46899 return resultobj;
46900 fail:
46901 return NULL;
46902 }
46903
46904
46905 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46906 PyObject *resultobj = 0;
46907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46908 wxBitmap *arg2 = 0 ;
46909 void *argp1 = 0 ;
46910 int res1 = 0 ;
46911 void *argp2 = 0 ;
46912 int res2 = 0 ;
46913 PyObject * obj0 = 0 ;
46914 PyObject * obj1 = 0 ;
46915 char * kwnames[] = {
46916 (char *) "self",(char *) "bmpDisabled", NULL
46917 };
46918
46919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46921 if (!SWIG_IsOK(res1)) {
46922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46923 }
46924 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46925 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46926 if (!SWIG_IsOK(res2)) {
46927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46928 }
46929 if (!argp2) {
46930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46931 }
46932 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46933 {
46934 PyThreadState* __tstate = wxPyBeginAllowThreads();
46935 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46936 wxPyEndAllowThreads(__tstate);
46937 if (PyErr_Occurred()) SWIG_fail;
46938 }
46939 resultobj = SWIG_Py_Void();
46940 return resultobj;
46941 fail:
46942 return NULL;
46943 }
46944
46945
46946 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46947 PyObject *resultobj = 0;
46948 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46949 wxBitmap *result = 0 ;
46950 void *argp1 = 0 ;
46951 int res1 = 0 ;
46952 PyObject *swig_obj[1] ;
46953
46954 if (!args) SWIG_fail;
46955 swig_obj[0] = args;
46956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46957 if (!SWIG_IsOK(res1)) {
46958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46959 }
46960 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46961 {
46962 PyThreadState* __tstate = wxPyBeginAllowThreads();
46963 {
46964 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
46965 result = (wxBitmap *) &_result_ref;
46966 }
46967 wxPyEndAllowThreads(__tstate);
46968 if (PyErr_Occurred()) SWIG_fail;
46969 }
46970 {
46971 wxBitmap* resultptr = new wxBitmap(*result);
46972 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46973 }
46974 return resultobj;
46975 fail:
46976 return NULL;
46977 }
46978
46979
46980 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46981 PyObject *resultobj = 0;
46982 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46983 int arg2 ;
46984 void *argp1 = 0 ;
46985 int res1 = 0 ;
46986 int val2 ;
46987 int ecode2 = 0 ;
46988 PyObject * obj0 = 0 ;
46989 PyObject * obj1 = 0 ;
46990 char * kwnames[] = {
46991 (char *) "self",(char *) "nWidth", NULL
46992 };
46993
46994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
46995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46996 if (!SWIG_IsOK(res1)) {
46997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46998 }
46999 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47000 ecode2 = SWIG_AsVal_int(obj1, &val2);
47001 if (!SWIG_IsOK(ecode2)) {
47002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47003 }
47004 arg2 = static_cast< int >(val2);
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 wxMenuItem_SetMarginWidth(arg1,arg2);
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 resultobj = SWIG_Py_Void();
47012 return resultobj;
47013 fail:
47014 return NULL;
47015 }
47016
47017
47018 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47019 PyObject *resultobj = 0;
47020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47021 int result;
47022 void *argp1 = 0 ;
47023 int res1 = 0 ;
47024 PyObject *swig_obj[1] ;
47025
47026 if (!args) SWIG_fail;
47027 swig_obj[0] = args;
47028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47029 if (!SWIG_IsOK(res1)) {
47030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47031 }
47032 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47033 {
47034 PyThreadState* __tstate = wxPyBeginAllowThreads();
47035 result = (int)wxMenuItem_GetMarginWidth(arg1);
47036 wxPyEndAllowThreads(__tstate);
47037 if (PyErr_Occurred()) SWIG_fail;
47038 }
47039 resultobj = SWIG_From_int(static_cast< int >(result));
47040 return resultobj;
47041 fail:
47042 return NULL;
47043 }
47044
47045
47046 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47047 PyObject *resultobj = 0;
47048 int result;
47049
47050 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 result = (int)wxMenuItem_GetDefaultMarginWidth();
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_From_int(static_cast< int >(result));
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47065 PyObject *resultobj = 0;
47066 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47067 bool result;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 PyObject *swig_obj[1] ;
47071
47072 if (!args) SWIG_fail;
47073 swig_obj[0] = args;
47074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47075 if (!SWIG_IsOK(res1)) {
47076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47077 }
47078 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47079 {
47080 PyThreadState* __tstate = wxPyBeginAllowThreads();
47081 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47082 wxPyEndAllowThreads(__tstate);
47083 if (PyErr_Occurred()) SWIG_fail;
47084 }
47085 {
47086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47087 }
47088 return resultobj;
47089 fail:
47090 return NULL;
47091 }
47092
47093
47094 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47095 PyObject *resultobj = 0;
47096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47097 bool arg2 = (bool) true ;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 bool val2 ;
47101 int ecode2 = 0 ;
47102 PyObject * obj0 = 0 ;
47103 PyObject * obj1 = 0 ;
47104 char * kwnames[] = {
47105 (char *) "self",(char *) "ownerDrawn", NULL
47106 };
47107
47108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47110 if (!SWIG_IsOK(res1)) {
47111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47112 }
47113 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47114 if (obj1) {
47115 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47116 if (!SWIG_IsOK(ecode2)) {
47117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47118 }
47119 arg2 = static_cast< bool >(val2);
47120 }
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47124 wxPyEndAllowThreads(__tstate);
47125 if (PyErr_Occurred()) SWIG_fail;
47126 }
47127 resultobj = SWIG_Py_Void();
47128 return resultobj;
47129 fail:
47130 return NULL;
47131 }
47132
47133
47134 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47135 PyObject *resultobj = 0;
47136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47137 void *argp1 = 0 ;
47138 int res1 = 0 ;
47139 PyObject *swig_obj[1] ;
47140
47141 if (!args) SWIG_fail;
47142 swig_obj[0] = args;
47143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47144 if (!SWIG_IsOK(res1)) {
47145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47146 }
47147 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47148 {
47149 PyThreadState* __tstate = wxPyBeginAllowThreads();
47150 wxMenuItem_ResetOwnerDrawn(arg1);
47151 wxPyEndAllowThreads(__tstate);
47152 if (PyErr_Occurred()) SWIG_fail;
47153 }
47154 resultobj = SWIG_Py_Void();
47155 return resultobj;
47156 fail:
47157 return NULL;
47158 }
47159
47160
47161 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47162 PyObject *obj;
47163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47164 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47165 return SWIG_Py_Void();
47166 }
47167
47168 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47169 return SWIG_Python_InitShadowInstance(args);
47170 }
47171
47172 SWIGINTERN int ControlNameStr_set(PyObject *) {
47173 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47174 return 1;
47175 }
47176
47177
47178 SWIGINTERN PyObject *ControlNameStr_get(void) {
47179 PyObject *pyobj = 0;
47180
47181 {
47182 #if wxUSE_UNICODE
47183 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47184 #else
47185 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47186 #endif
47187 }
47188 return pyobj;
47189 }
47190
47191
47192 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47193 PyObject *resultobj = 0;
47194 wxWindow *arg1 = (wxWindow *) 0 ;
47195 int arg2 = (int) -1 ;
47196 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47197 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47198 wxSize const &arg4_defvalue = wxDefaultSize ;
47199 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47200 long arg5 = (long) 0 ;
47201 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47202 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47203 wxString const &arg7_defvalue = wxPyControlNameStr ;
47204 wxString *arg7 = (wxString *) &arg7_defvalue ;
47205 wxControl *result = 0 ;
47206 void *argp1 = 0 ;
47207 int res1 = 0 ;
47208 int val2 ;
47209 int ecode2 = 0 ;
47210 wxPoint temp3 ;
47211 wxSize temp4 ;
47212 long val5 ;
47213 int ecode5 = 0 ;
47214 void *argp6 = 0 ;
47215 int res6 = 0 ;
47216 bool temp7 = false ;
47217 PyObject * obj0 = 0 ;
47218 PyObject * obj1 = 0 ;
47219 PyObject * obj2 = 0 ;
47220 PyObject * obj3 = 0 ;
47221 PyObject * obj4 = 0 ;
47222 PyObject * obj5 = 0 ;
47223 PyObject * obj6 = 0 ;
47224 char * kwnames[] = {
47225 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47226 };
47227
47228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47230 if (!SWIG_IsOK(res1)) {
47231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47232 }
47233 arg1 = reinterpret_cast< wxWindow * >(argp1);
47234 if (obj1) {
47235 ecode2 = SWIG_AsVal_int(obj1, &val2);
47236 if (!SWIG_IsOK(ecode2)) {
47237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47238 }
47239 arg2 = static_cast< int >(val2);
47240 }
47241 if (obj2) {
47242 {
47243 arg3 = &temp3;
47244 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47245 }
47246 }
47247 if (obj3) {
47248 {
47249 arg4 = &temp4;
47250 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47251 }
47252 }
47253 if (obj4) {
47254 ecode5 = SWIG_AsVal_long(obj4, &val5);
47255 if (!SWIG_IsOK(ecode5)) {
47256 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47257 }
47258 arg5 = static_cast< long >(val5);
47259 }
47260 if (obj5) {
47261 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47262 if (!SWIG_IsOK(res6)) {
47263 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47264 }
47265 if (!argp6) {
47266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47267 }
47268 arg6 = reinterpret_cast< wxValidator * >(argp6);
47269 }
47270 if (obj6) {
47271 {
47272 arg7 = wxString_in_helper(obj6);
47273 if (arg7 == NULL) SWIG_fail;
47274 temp7 = true;
47275 }
47276 }
47277 {
47278 if (!wxPyCheckForApp()) SWIG_fail;
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47285 {
47286 if (temp7)
47287 delete arg7;
47288 }
47289 return resultobj;
47290 fail:
47291 {
47292 if (temp7)
47293 delete arg7;
47294 }
47295 return NULL;
47296 }
47297
47298
47299 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47300 PyObject *resultobj = 0;
47301 wxControl *result = 0 ;
47302
47303 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47304 {
47305 if (!wxPyCheckForApp()) SWIG_fail;
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 result = (wxControl *)new wxControl();
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47319 PyObject *resultobj = 0;
47320 wxControl *arg1 = (wxControl *) 0 ;
47321 wxWindow *arg2 = (wxWindow *) 0 ;
47322 int arg3 = (int) -1 ;
47323 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47324 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47325 wxSize const &arg5_defvalue = wxDefaultSize ;
47326 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47327 long arg6 = (long) 0 ;
47328 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47329 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47330 wxString const &arg8_defvalue = wxPyControlNameStr ;
47331 wxString *arg8 = (wxString *) &arg8_defvalue ;
47332 bool result;
47333 void *argp1 = 0 ;
47334 int res1 = 0 ;
47335 void *argp2 = 0 ;
47336 int res2 = 0 ;
47337 int val3 ;
47338 int ecode3 = 0 ;
47339 wxPoint temp4 ;
47340 wxSize temp5 ;
47341 long val6 ;
47342 int ecode6 = 0 ;
47343 void *argp7 = 0 ;
47344 int res7 = 0 ;
47345 bool temp8 = false ;
47346 PyObject * obj0 = 0 ;
47347 PyObject * obj1 = 0 ;
47348 PyObject * obj2 = 0 ;
47349 PyObject * obj3 = 0 ;
47350 PyObject * obj4 = 0 ;
47351 PyObject * obj5 = 0 ;
47352 PyObject * obj6 = 0 ;
47353 PyObject * obj7 = 0 ;
47354 char * kwnames[] = {
47355 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47356 };
47357
47358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47362 }
47363 arg1 = reinterpret_cast< wxControl * >(argp1);
47364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47365 if (!SWIG_IsOK(res2)) {
47366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47367 }
47368 arg2 = reinterpret_cast< wxWindow * >(argp2);
47369 if (obj2) {
47370 ecode3 = SWIG_AsVal_int(obj2, &val3);
47371 if (!SWIG_IsOK(ecode3)) {
47372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47373 }
47374 arg3 = static_cast< int >(val3);
47375 }
47376 if (obj3) {
47377 {
47378 arg4 = &temp4;
47379 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47380 }
47381 }
47382 if (obj4) {
47383 {
47384 arg5 = &temp5;
47385 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47386 }
47387 }
47388 if (obj5) {
47389 ecode6 = SWIG_AsVal_long(obj5, &val6);
47390 if (!SWIG_IsOK(ecode6)) {
47391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47392 }
47393 arg6 = static_cast< long >(val6);
47394 }
47395 if (obj6) {
47396 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47397 if (!SWIG_IsOK(res7)) {
47398 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47399 }
47400 if (!argp7) {
47401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47402 }
47403 arg7 = reinterpret_cast< wxValidator * >(argp7);
47404 }
47405 if (obj7) {
47406 {
47407 arg8 = wxString_in_helper(obj7);
47408 if (arg8 == NULL) SWIG_fail;
47409 temp8 = true;
47410 }
47411 }
47412 {
47413 PyThreadState* __tstate = wxPyBeginAllowThreads();
47414 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47415 wxPyEndAllowThreads(__tstate);
47416 if (PyErr_Occurred()) SWIG_fail;
47417 }
47418 {
47419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47420 }
47421 {
47422 if (temp8)
47423 delete arg8;
47424 }
47425 return resultobj;
47426 fail:
47427 {
47428 if (temp8)
47429 delete arg8;
47430 }
47431 return NULL;
47432 }
47433
47434
47435 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47436 PyObject *resultobj = 0;
47437 wxControl *arg1 = (wxControl *) 0 ;
47438 int result;
47439 void *argp1 = 0 ;
47440 int res1 = 0 ;
47441 PyObject *swig_obj[1] ;
47442
47443 if (!args) SWIG_fail;
47444 swig_obj[0] = args;
47445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47446 if (!SWIG_IsOK(res1)) {
47447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47448 }
47449 arg1 = reinterpret_cast< wxControl * >(argp1);
47450 {
47451 PyThreadState* __tstate = wxPyBeginAllowThreads();
47452 result = (int)((wxControl const *)arg1)->GetAlignment();
47453 wxPyEndAllowThreads(__tstate);
47454 if (PyErr_Occurred()) SWIG_fail;
47455 }
47456 resultobj = SWIG_From_int(static_cast< int >(result));
47457 return resultobj;
47458 fail:
47459 return NULL;
47460 }
47461
47462
47463 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47464 PyObject *resultobj = 0;
47465 wxControl *arg1 = (wxControl *) 0 ;
47466 wxString result;
47467 void *argp1 = 0 ;
47468 int res1 = 0 ;
47469 PyObject *swig_obj[1] ;
47470
47471 if (!args) SWIG_fail;
47472 swig_obj[0] = args;
47473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47474 if (!SWIG_IsOK(res1)) {
47475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47476 }
47477 arg1 = reinterpret_cast< wxControl * >(argp1);
47478 {
47479 PyThreadState* __tstate = wxPyBeginAllowThreads();
47480 result = ((wxControl const *)arg1)->GetLabelText();
47481 wxPyEndAllowThreads(__tstate);
47482 if (PyErr_Occurred()) SWIG_fail;
47483 }
47484 {
47485 #if wxUSE_UNICODE
47486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47487 #else
47488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47489 #endif
47490 }
47491 return resultobj;
47492 fail:
47493 return NULL;
47494 }
47495
47496
47497 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47498 PyObject *resultobj = 0;
47499 wxControl *arg1 = (wxControl *) 0 ;
47500 wxCommandEvent *arg2 = 0 ;
47501 void *argp1 = 0 ;
47502 int res1 = 0 ;
47503 void *argp2 = 0 ;
47504 int res2 = 0 ;
47505 PyObject * obj0 = 0 ;
47506 PyObject * obj1 = 0 ;
47507 char * kwnames[] = {
47508 (char *) "self",(char *) "event", NULL
47509 };
47510
47511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47513 if (!SWIG_IsOK(res1)) {
47514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47515 }
47516 arg1 = reinterpret_cast< wxControl * >(argp1);
47517 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47518 if (!SWIG_IsOK(res2)) {
47519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47520 }
47521 if (!argp2) {
47522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47523 }
47524 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47525 {
47526 PyThreadState* __tstate = wxPyBeginAllowThreads();
47527 (arg1)->Command(*arg2);
47528 wxPyEndAllowThreads(__tstate);
47529 if (PyErr_Occurred()) SWIG_fail;
47530 }
47531 resultobj = SWIG_Py_Void();
47532 return resultobj;
47533 fail:
47534 return NULL;
47535 }
47536
47537
47538 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47539 PyObject *resultobj = 0;
47540 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47541 SwigValueWrapper<wxVisualAttributes > result;
47542 int val1 ;
47543 int ecode1 = 0 ;
47544 PyObject * obj0 = 0 ;
47545 char * kwnames[] = {
47546 (char *) "variant", NULL
47547 };
47548
47549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47550 if (obj0) {
47551 ecode1 = SWIG_AsVal_int(obj0, &val1);
47552 if (!SWIG_IsOK(ecode1)) {
47553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47554 }
47555 arg1 = static_cast< wxWindowVariant >(val1);
47556 }
47557 {
47558 if (!wxPyCheckForApp()) SWIG_fail;
47559 PyThreadState* __tstate = wxPyBeginAllowThreads();
47560 result = wxControl::GetClassDefaultAttributes(arg1);
47561 wxPyEndAllowThreads(__tstate);
47562 if (PyErr_Occurred()) SWIG_fail;
47563 }
47564 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47565 return resultobj;
47566 fail:
47567 return NULL;
47568 }
47569
47570
47571 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47572 PyObject *obj;
47573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47574 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47575 return SWIG_Py_Void();
47576 }
47577
47578 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47579 return SWIG_Python_InitShadowInstance(args);
47580 }
47581
47582 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47583 PyObject *resultobj = 0;
47584 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47585 wxString *arg2 = 0 ;
47586 PyObject *arg3 = (PyObject *) NULL ;
47587 int result;
47588 void *argp1 = 0 ;
47589 int res1 = 0 ;
47590 bool temp2 = false ;
47591 PyObject * obj0 = 0 ;
47592 PyObject * obj1 = 0 ;
47593 PyObject * obj2 = 0 ;
47594 char * kwnames[] = {
47595 (char *) "self",(char *) "item",(char *) "clientData", NULL
47596 };
47597
47598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47600 if (!SWIG_IsOK(res1)) {
47601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47602 }
47603 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47604 {
47605 arg2 = wxString_in_helper(obj1);
47606 if (arg2 == NULL) SWIG_fail;
47607 temp2 = true;
47608 }
47609 if (obj2) {
47610 arg3 = obj2;
47611 }
47612 {
47613 PyThreadState* __tstate = wxPyBeginAllowThreads();
47614 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47615 wxPyEndAllowThreads(__tstate);
47616 if (PyErr_Occurred()) SWIG_fail;
47617 }
47618 resultobj = SWIG_From_int(static_cast< int >(result));
47619 {
47620 if (temp2)
47621 delete arg2;
47622 }
47623 return resultobj;
47624 fail:
47625 {
47626 if (temp2)
47627 delete arg2;
47628 }
47629 return NULL;
47630 }
47631
47632
47633 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47634 PyObject *resultobj = 0;
47635 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47636 wxArrayString *arg2 = 0 ;
47637 void *argp1 = 0 ;
47638 int res1 = 0 ;
47639 bool temp2 = false ;
47640 PyObject * obj0 = 0 ;
47641 PyObject * obj1 = 0 ;
47642 char * kwnames[] = {
47643 (char *) "self",(char *) "strings", NULL
47644 };
47645
47646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47648 if (!SWIG_IsOK(res1)) {
47649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47650 }
47651 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47652 {
47653 if (! PySequence_Check(obj1)) {
47654 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47655 SWIG_fail;
47656 }
47657 arg2 = new wxArrayString;
47658 temp2 = true;
47659 int i, len=PySequence_Length(obj1);
47660 for (i=0; i<len; i++) {
47661 PyObject* item = PySequence_GetItem(obj1, i);
47662 wxString* s = wxString_in_helper(item);
47663 if (PyErr_Occurred()) SWIG_fail;
47664 arg2->Add(*s);
47665 delete s;
47666 Py_DECREF(item);
47667 }
47668 }
47669 {
47670 PyThreadState* __tstate = wxPyBeginAllowThreads();
47671 (arg1)->Append((wxArrayString const &)*arg2);
47672 wxPyEndAllowThreads(__tstate);
47673 if (PyErr_Occurred()) SWIG_fail;
47674 }
47675 resultobj = SWIG_Py_Void();
47676 {
47677 if (temp2) delete arg2;
47678 }
47679 return resultobj;
47680 fail:
47681 {
47682 if (temp2) delete arg2;
47683 }
47684 return NULL;
47685 }
47686
47687
47688 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47689 PyObject *resultobj = 0;
47690 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47691 wxString *arg2 = 0 ;
47692 int arg3 ;
47693 PyObject *arg4 = (PyObject *) NULL ;
47694 int result;
47695 void *argp1 = 0 ;
47696 int res1 = 0 ;
47697 bool temp2 = false ;
47698 int val3 ;
47699 int ecode3 = 0 ;
47700 PyObject * obj0 = 0 ;
47701 PyObject * obj1 = 0 ;
47702 PyObject * obj2 = 0 ;
47703 PyObject * obj3 = 0 ;
47704 char * kwnames[] = {
47705 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47706 };
47707
47708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47710 if (!SWIG_IsOK(res1)) {
47711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47712 }
47713 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47714 {
47715 arg2 = wxString_in_helper(obj1);
47716 if (arg2 == NULL) SWIG_fail;
47717 temp2 = true;
47718 }
47719 ecode3 = SWIG_AsVal_int(obj2, &val3);
47720 if (!SWIG_IsOK(ecode3)) {
47721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47722 }
47723 arg3 = static_cast< int >(val3);
47724 if (obj3) {
47725 arg4 = obj3;
47726 }
47727 {
47728 PyThreadState* __tstate = wxPyBeginAllowThreads();
47729 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47730 wxPyEndAllowThreads(__tstate);
47731 if (PyErr_Occurred()) SWIG_fail;
47732 }
47733 resultobj = SWIG_From_int(static_cast< int >(result));
47734 {
47735 if (temp2)
47736 delete arg2;
47737 }
47738 return resultobj;
47739 fail:
47740 {
47741 if (temp2)
47742 delete arg2;
47743 }
47744 return NULL;
47745 }
47746
47747
47748 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47749 PyObject *resultobj = 0;
47750 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47751 void *argp1 = 0 ;
47752 int res1 = 0 ;
47753 PyObject *swig_obj[1] ;
47754
47755 if (!args) SWIG_fail;
47756 swig_obj[0] = args;
47757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47758 if (!SWIG_IsOK(res1)) {
47759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47760 }
47761 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47762 {
47763 PyThreadState* __tstate = wxPyBeginAllowThreads();
47764 (arg1)->Clear();
47765 wxPyEndAllowThreads(__tstate);
47766 if (PyErr_Occurred()) SWIG_fail;
47767 }
47768 resultobj = SWIG_Py_Void();
47769 return resultobj;
47770 fail:
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47776 PyObject *resultobj = 0;
47777 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47778 int arg2 ;
47779 void *argp1 = 0 ;
47780 int res1 = 0 ;
47781 int val2 ;
47782 int ecode2 = 0 ;
47783 PyObject * obj0 = 0 ;
47784 PyObject * obj1 = 0 ;
47785 char * kwnames[] = {
47786 (char *) "self",(char *) "n", NULL
47787 };
47788
47789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47791 if (!SWIG_IsOK(res1)) {
47792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47793 }
47794 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47795 ecode2 = SWIG_AsVal_int(obj1, &val2);
47796 if (!SWIG_IsOK(ecode2)) {
47797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
47798 }
47799 arg2 = static_cast< int >(val2);
47800 {
47801 PyThreadState* __tstate = wxPyBeginAllowThreads();
47802 (arg1)->Delete(arg2);
47803 wxPyEndAllowThreads(__tstate);
47804 if (PyErr_Occurred()) SWIG_fail;
47805 }
47806 resultobj = SWIG_Py_Void();
47807 return resultobj;
47808 fail:
47809 return NULL;
47810 }
47811
47812
47813 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47814 PyObject *resultobj = 0;
47815 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47816 int arg2 ;
47817 PyObject *result = 0 ;
47818 void *argp1 = 0 ;
47819 int res1 = 0 ;
47820 int val2 ;
47821 int ecode2 = 0 ;
47822 PyObject * obj0 = 0 ;
47823 PyObject * obj1 = 0 ;
47824 char * kwnames[] = {
47825 (char *) "self",(char *) "n", NULL
47826 };
47827
47828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47830 if (!SWIG_IsOK(res1)) {
47831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47832 }
47833 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47834 ecode2 = SWIG_AsVal_int(obj1, &val2);
47835 if (!SWIG_IsOK(ecode2)) {
47836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
47837 }
47838 arg2 = static_cast< int >(val2);
47839 {
47840 PyThreadState* __tstate = wxPyBeginAllowThreads();
47841 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47842 wxPyEndAllowThreads(__tstate);
47843 if (PyErr_Occurred()) SWIG_fail;
47844 }
47845 resultobj = result;
47846 return resultobj;
47847 fail:
47848 return NULL;
47849 }
47850
47851
47852 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47853 PyObject *resultobj = 0;
47854 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47855 int arg2 ;
47856 PyObject *arg3 = (PyObject *) 0 ;
47857 void *argp1 = 0 ;
47858 int res1 = 0 ;
47859 int val2 ;
47860 int ecode2 = 0 ;
47861 PyObject * obj0 = 0 ;
47862 PyObject * obj1 = 0 ;
47863 PyObject * obj2 = 0 ;
47864 char * kwnames[] = {
47865 (char *) "self",(char *) "n",(char *) "clientData", NULL
47866 };
47867
47868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47870 if (!SWIG_IsOK(res1)) {
47871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47872 }
47873 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47874 ecode2 = SWIG_AsVal_int(obj1, &val2);
47875 if (!SWIG_IsOK(ecode2)) {
47876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
47877 }
47878 arg2 = static_cast< int >(val2);
47879 arg3 = obj2;
47880 {
47881 PyThreadState* __tstate = wxPyBeginAllowThreads();
47882 wxItemContainer_SetClientData(arg1,arg2,arg3);
47883 wxPyEndAllowThreads(__tstate);
47884 if (PyErr_Occurred()) SWIG_fail;
47885 }
47886 resultobj = SWIG_Py_Void();
47887 return resultobj;
47888 fail:
47889 return NULL;
47890 }
47891
47892
47893 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47894 PyObject *resultobj = 0;
47895 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47896 int result;
47897 void *argp1 = 0 ;
47898 int res1 = 0 ;
47899 PyObject *swig_obj[1] ;
47900
47901 if (!args) SWIG_fail;
47902 swig_obj[0] = args;
47903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47904 if (!SWIG_IsOK(res1)) {
47905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47906 }
47907 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 result = (int)((wxItemContainer const *)arg1)->GetCount();
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = SWIG_From_int(static_cast< int >(result));
47915 return resultobj;
47916 fail:
47917 return NULL;
47918 }
47919
47920
47921 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47922 PyObject *resultobj = 0;
47923 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47924 bool result;
47925 void *argp1 = 0 ;
47926 int res1 = 0 ;
47927 PyObject *swig_obj[1] ;
47928
47929 if (!args) SWIG_fail;
47930 swig_obj[0] = args;
47931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47932 if (!SWIG_IsOK(res1)) {
47933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47934 }
47935 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47936 {
47937 PyThreadState* __tstate = wxPyBeginAllowThreads();
47938 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47939 wxPyEndAllowThreads(__tstate);
47940 if (PyErr_Occurred()) SWIG_fail;
47941 }
47942 {
47943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47944 }
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47952 PyObject *resultobj = 0;
47953 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47954 int arg2 ;
47955 wxString result;
47956 void *argp1 = 0 ;
47957 int res1 = 0 ;
47958 int val2 ;
47959 int ecode2 = 0 ;
47960 PyObject * obj0 = 0 ;
47961 PyObject * obj1 = 0 ;
47962 char * kwnames[] = {
47963 (char *) "self",(char *) "n", NULL
47964 };
47965
47966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47968 if (!SWIG_IsOK(res1)) {
47969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47970 }
47971 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47972 ecode2 = SWIG_AsVal_int(obj1, &val2);
47973 if (!SWIG_IsOK(ecode2)) {
47974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
47975 }
47976 arg2 = static_cast< int >(val2);
47977 {
47978 PyThreadState* __tstate = wxPyBeginAllowThreads();
47979 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47980 wxPyEndAllowThreads(__tstate);
47981 if (PyErr_Occurred()) SWIG_fail;
47982 }
47983 {
47984 #if wxUSE_UNICODE
47985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47986 #else
47987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47988 #endif
47989 }
47990 return resultobj;
47991 fail:
47992 return NULL;
47993 }
47994
47995
47996 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47997 PyObject *resultobj = 0;
47998 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47999 wxArrayString result;
48000 void *argp1 = 0 ;
48001 int res1 = 0 ;
48002 PyObject *swig_obj[1] ;
48003
48004 if (!args) SWIG_fail;
48005 swig_obj[0] = args;
48006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48007 if (!SWIG_IsOK(res1)) {
48008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48009 }
48010 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48011 {
48012 PyThreadState* __tstate = wxPyBeginAllowThreads();
48013 result = ((wxItemContainer const *)arg1)->GetStrings();
48014 wxPyEndAllowThreads(__tstate);
48015 if (PyErr_Occurred()) SWIG_fail;
48016 }
48017 {
48018 resultobj = wxArrayString2PyList_helper(result);
48019 }
48020 return resultobj;
48021 fail:
48022 return NULL;
48023 }
48024
48025
48026 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48027 PyObject *resultobj = 0;
48028 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48029 int arg2 ;
48030 wxString *arg3 = 0 ;
48031 void *argp1 = 0 ;
48032 int res1 = 0 ;
48033 int val2 ;
48034 int ecode2 = 0 ;
48035 bool temp3 = false ;
48036 PyObject * obj0 = 0 ;
48037 PyObject * obj1 = 0 ;
48038 PyObject * obj2 = 0 ;
48039 char * kwnames[] = {
48040 (char *) "self",(char *) "n",(char *) "s", NULL
48041 };
48042
48043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48045 if (!SWIG_IsOK(res1)) {
48046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48047 }
48048 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48049 ecode2 = SWIG_AsVal_int(obj1, &val2);
48050 if (!SWIG_IsOK(ecode2)) {
48051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48052 }
48053 arg2 = static_cast< int >(val2);
48054 {
48055 arg3 = wxString_in_helper(obj2);
48056 if (arg3 == NULL) SWIG_fail;
48057 temp3 = true;
48058 }
48059 {
48060 PyThreadState* __tstate = wxPyBeginAllowThreads();
48061 (arg1)->SetString(arg2,(wxString const &)*arg3);
48062 wxPyEndAllowThreads(__tstate);
48063 if (PyErr_Occurred()) SWIG_fail;
48064 }
48065 resultobj = SWIG_Py_Void();
48066 {
48067 if (temp3)
48068 delete arg3;
48069 }
48070 return resultobj;
48071 fail:
48072 {
48073 if (temp3)
48074 delete arg3;
48075 }
48076 return NULL;
48077 }
48078
48079
48080 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48081 PyObject *resultobj = 0;
48082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48083 wxString *arg2 = 0 ;
48084 int result;
48085 void *argp1 = 0 ;
48086 int res1 = 0 ;
48087 bool temp2 = false ;
48088 PyObject * obj0 = 0 ;
48089 PyObject * obj1 = 0 ;
48090 char * kwnames[] = {
48091 (char *) "self",(char *) "s", NULL
48092 };
48093
48094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48096 if (!SWIG_IsOK(res1)) {
48097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48098 }
48099 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48100 {
48101 arg2 = wxString_in_helper(obj1);
48102 if (arg2 == NULL) SWIG_fail;
48103 temp2 = true;
48104 }
48105 {
48106 PyThreadState* __tstate = wxPyBeginAllowThreads();
48107 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48108 wxPyEndAllowThreads(__tstate);
48109 if (PyErr_Occurred()) SWIG_fail;
48110 }
48111 resultobj = SWIG_From_int(static_cast< int >(result));
48112 {
48113 if (temp2)
48114 delete arg2;
48115 }
48116 return resultobj;
48117 fail:
48118 {
48119 if (temp2)
48120 delete arg2;
48121 }
48122 return NULL;
48123 }
48124
48125
48126 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48127 PyObject *resultobj = 0;
48128 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48129 int arg2 ;
48130 void *argp1 = 0 ;
48131 int res1 = 0 ;
48132 int val2 ;
48133 int ecode2 = 0 ;
48134 PyObject * obj0 = 0 ;
48135 PyObject * obj1 = 0 ;
48136 char * kwnames[] = {
48137 (char *) "self",(char *) "n", NULL
48138 };
48139
48140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48142 if (!SWIG_IsOK(res1)) {
48143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48144 }
48145 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48146 ecode2 = SWIG_AsVal_int(obj1, &val2);
48147 if (!SWIG_IsOK(ecode2)) {
48148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48149 }
48150 arg2 = static_cast< int >(val2);
48151 {
48152 PyThreadState* __tstate = wxPyBeginAllowThreads();
48153 (arg1)->SetSelection(arg2);
48154 wxPyEndAllowThreads(__tstate);
48155 if (PyErr_Occurred()) SWIG_fail;
48156 }
48157 resultobj = SWIG_Py_Void();
48158 return resultobj;
48159 fail:
48160 return NULL;
48161 }
48162
48163
48164 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48165 PyObject *resultobj = 0;
48166 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48167 int result;
48168 void *argp1 = 0 ;
48169 int res1 = 0 ;
48170 PyObject *swig_obj[1] ;
48171
48172 if (!args) SWIG_fail;
48173 swig_obj[0] = args;
48174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48175 if (!SWIG_IsOK(res1)) {
48176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48177 }
48178 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48179 {
48180 PyThreadState* __tstate = wxPyBeginAllowThreads();
48181 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48182 wxPyEndAllowThreads(__tstate);
48183 if (PyErr_Occurred()) SWIG_fail;
48184 }
48185 resultobj = SWIG_From_int(static_cast< int >(result));
48186 return resultobj;
48187 fail:
48188 return NULL;
48189 }
48190
48191
48192 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48193 PyObject *resultobj = 0;
48194 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48195 wxString *arg2 = 0 ;
48196 bool result;
48197 void *argp1 = 0 ;
48198 int res1 = 0 ;
48199 bool temp2 = false ;
48200 PyObject * obj0 = 0 ;
48201 PyObject * obj1 = 0 ;
48202 char * kwnames[] = {
48203 (char *) "self",(char *) "s", NULL
48204 };
48205
48206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48208 if (!SWIG_IsOK(res1)) {
48209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48210 }
48211 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48212 {
48213 arg2 = wxString_in_helper(obj1);
48214 if (arg2 == NULL) SWIG_fail;
48215 temp2 = true;
48216 }
48217 {
48218 PyThreadState* __tstate = wxPyBeginAllowThreads();
48219 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48220 wxPyEndAllowThreads(__tstate);
48221 if (PyErr_Occurred()) SWIG_fail;
48222 }
48223 {
48224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48225 }
48226 {
48227 if (temp2)
48228 delete arg2;
48229 }
48230 return resultobj;
48231 fail:
48232 {
48233 if (temp2)
48234 delete arg2;
48235 }
48236 return NULL;
48237 }
48238
48239
48240 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48241 PyObject *resultobj = 0;
48242 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48243 wxString result;
48244 void *argp1 = 0 ;
48245 int res1 = 0 ;
48246 PyObject *swig_obj[1] ;
48247
48248 if (!args) SWIG_fail;
48249 swig_obj[0] = args;
48250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48251 if (!SWIG_IsOK(res1)) {
48252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48253 }
48254 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48255 {
48256 PyThreadState* __tstate = wxPyBeginAllowThreads();
48257 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48258 wxPyEndAllowThreads(__tstate);
48259 if (PyErr_Occurred()) SWIG_fail;
48260 }
48261 {
48262 #if wxUSE_UNICODE
48263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48264 #else
48265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48266 #endif
48267 }
48268 return resultobj;
48269 fail:
48270 return NULL;
48271 }
48272
48273
48274 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48275 PyObject *resultobj = 0;
48276 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48277 int arg2 ;
48278 void *argp1 = 0 ;
48279 int res1 = 0 ;
48280 int val2 ;
48281 int ecode2 = 0 ;
48282 PyObject * obj0 = 0 ;
48283 PyObject * obj1 = 0 ;
48284 char * kwnames[] = {
48285 (char *) "self",(char *) "n", NULL
48286 };
48287
48288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48290 if (!SWIG_IsOK(res1)) {
48291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48292 }
48293 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48294 ecode2 = SWIG_AsVal_int(obj1, &val2);
48295 if (!SWIG_IsOK(ecode2)) {
48296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48297 }
48298 arg2 = static_cast< int >(val2);
48299 {
48300 PyThreadState* __tstate = wxPyBeginAllowThreads();
48301 (arg1)->Select(arg2);
48302 wxPyEndAllowThreads(__tstate);
48303 if (PyErr_Occurred()) SWIG_fail;
48304 }
48305 resultobj = SWIG_Py_Void();
48306 return resultobj;
48307 fail:
48308 return NULL;
48309 }
48310
48311
48312 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48313 PyObject *obj;
48314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48315 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48316 return SWIG_Py_Void();
48317 }
48318
48319 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48320 PyObject *obj;
48321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48322 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48323 return SWIG_Py_Void();
48324 }
48325
48326 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48327 PyObject *resultobj = 0;
48328 wxSizerItem *result = 0 ;
48329
48330 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48331 {
48332 PyThreadState* __tstate = wxPyBeginAllowThreads();
48333 result = (wxSizerItem *)new wxSizerItem();
48334 wxPyEndAllowThreads(__tstate);
48335 if (PyErr_Occurred()) SWIG_fail;
48336 }
48337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48338 return resultobj;
48339 fail:
48340 return NULL;
48341 }
48342
48343
48344 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48345 PyObject *resultobj = 0;
48346 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48347 void *argp1 = 0 ;
48348 int res1 = 0 ;
48349 PyObject *swig_obj[1] ;
48350
48351 if (!args) SWIG_fail;
48352 swig_obj[0] = args;
48353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48354 if (!SWIG_IsOK(res1)) {
48355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48356 }
48357 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48358 {
48359 PyThreadState* __tstate = wxPyBeginAllowThreads();
48360 delete arg1;
48361
48362 wxPyEndAllowThreads(__tstate);
48363 if (PyErr_Occurred()) SWIG_fail;
48364 }
48365 resultobj = SWIG_Py_Void();
48366 return resultobj;
48367 fail:
48368 return NULL;
48369 }
48370
48371
48372 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48373 PyObject *resultobj = 0;
48374 wxWindow *arg1 = (wxWindow *) 0 ;
48375 int arg2 ;
48376 int arg3 ;
48377 int arg4 ;
48378 PyObject *arg5 = (PyObject *) NULL ;
48379 wxSizerItem *result = 0 ;
48380 void *argp1 = 0 ;
48381 int res1 = 0 ;
48382 int val2 ;
48383 int ecode2 = 0 ;
48384 int val3 ;
48385 int ecode3 = 0 ;
48386 int val4 ;
48387 int ecode4 = 0 ;
48388 PyObject * obj0 = 0 ;
48389 PyObject * obj1 = 0 ;
48390 PyObject * obj2 = 0 ;
48391 PyObject * obj3 = 0 ;
48392 PyObject * obj4 = 0 ;
48393 char * kwnames[] = {
48394 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48395 };
48396
48397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48399 if (!SWIG_IsOK(res1)) {
48400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48401 }
48402 arg1 = reinterpret_cast< wxWindow * >(argp1);
48403 ecode2 = SWIG_AsVal_int(obj1, &val2);
48404 if (!SWIG_IsOK(ecode2)) {
48405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48406 }
48407 arg2 = static_cast< int >(val2);
48408 ecode3 = SWIG_AsVal_int(obj2, &val3);
48409 if (!SWIG_IsOK(ecode3)) {
48410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48411 }
48412 arg3 = static_cast< int >(val3);
48413 ecode4 = SWIG_AsVal_int(obj3, &val4);
48414 if (!SWIG_IsOK(ecode4)) {
48415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48416 }
48417 arg4 = static_cast< int >(val4);
48418 if (obj4) {
48419 arg5 = obj4;
48420 }
48421 {
48422 PyThreadState* __tstate = wxPyBeginAllowThreads();
48423 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48424 wxPyEndAllowThreads(__tstate);
48425 if (PyErr_Occurred()) SWIG_fail;
48426 }
48427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48428 return resultobj;
48429 fail:
48430 return NULL;
48431 }
48432
48433
48434 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48435 PyObject *resultobj = 0;
48436 int arg1 ;
48437 int arg2 ;
48438 int arg3 ;
48439 int arg4 ;
48440 int arg5 ;
48441 PyObject *arg6 = (PyObject *) NULL ;
48442 wxSizerItem *result = 0 ;
48443 int val1 ;
48444 int ecode1 = 0 ;
48445 int val2 ;
48446 int ecode2 = 0 ;
48447 int val3 ;
48448 int ecode3 = 0 ;
48449 int val4 ;
48450 int ecode4 = 0 ;
48451 int val5 ;
48452 int ecode5 = 0 ;
48453 PyObject * obj0 = 0 ;
48454 PyObject * obj1 = 0 ;
48455 PyObject * obj2 = 0 ;
48456 PyObject * obj3 = 0 ;
48457 PyObject * obj4 = 0 ;
48458 PyObject * obj5 = 0 ;
48459 char * kwnames[] = {
48460 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48461 };
48462
48463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48464 ecode1 = SWIG_AsVal_int(obj0, &val1);
48465 if (!SWIG_IsOK(ecode1)) {
48466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48467 }
48468 arg1 = static_cast< int >(val1);
48469 ecode2 = SWIG_AsVal_int(obj1, &val2);
48470 if (!SWIG_IsOK(ecode2)) {
48471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48472 }
48473 arg2 = static_cast< int >(val2);
48474 ecode3 = SWIG_AsVal_int(obj2, &val3);
48475 if (!SWIG_IsOK(ecode3)) {
48476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48477 }
48478 arg3 = static_cast< int >(val3);
48479 ecode4 = SWIG_AsVal_int(obj3, &val4);
48480 if (!SWIG_IsOK(ecode4)) {
48481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48482 }
48483 arg4 = static_cast< int >(val4);
48484 ecode5 = SWIG_AsVal_int(obj4, &val5);
48485 if (!SWIG_IsOK(ecode5)) {
48486 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48487 }
48488 arg5 = static_cast< int >(val5);
48489 if (obj5) {
48490 arg6 = obj5;
48491 }
48492 {
48493 PyThreadState* __tstate = wxPyBeginAllowThreads();
48494 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48495 wxPyEndAllowThreads(__tstate);
48496 if (PyErr_Occurred()) SWIG_fail;
48497 }
48498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48499 return resultobj;
48500 fail:
48501 return NULL;
48502 }
48503
48504
48505 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48506 PyObject *resultobj = 0;
48507 wxSizer *arg1 = (wxSizer *) 0 ;
48508 int arg2 ;
48509 int arg3 ;
48510 int arg4 ;
48511 PyObject *arg5 = (PyObject *) NULL ;
48512 wxSizerItem *result = 0 ;
48513 int res1 = 0 ;
48514 int val2 ;
48515 int ecode2 = 0 ;
48516 int val3 ;
48517 int ecode3 = 0 ;
48518 int val4 ;
48519 int ecode4 = 0 ;
48520 PyObject * obj0 = 0 ;
48521 PyObject * obj1 = 0 ;
48522 PyObject * obj2 = 0 ;
48523 PyObject * obj3 = 0 ;
48524 PyObject * obj4 = 0 ;
48525 char * kwnames[] = {
48526 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48527 };
48528
48529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48530 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48531 if (!SWIG_IsOK(res1)) {
48532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48533 }
48534 ecode2 = SWIG_AsVal_int(obj1, &val2);
48535 if (!SWIG_IsOK(ecode2)) {
48536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48537 }
48538 arg2 = static_cast< int >(val2);
48539 ecode3 = SWIG_AsVal_int(obj2, &val3);
48540 if (!SWIG_IsOK(ecode3)) {
48541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48542 }
48543 arg3 = static_cast< int >(val3);
48544 ecode4 = SWIG_AsVal_int(obj3, &val4);
48545 if (!SWIG_IsOK(ecode4)) {
48546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48547 }
48548 arg4 = static_cast< int >(val4);
48549 if (obj4) {
48550 arg5 = obj4;
48551 }
48552 {
48553 PyThreadState* __tstate = wxPyBeginAllowThreads();
48554 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48555 wxPyEndAllowThreads(__tstate);
48556 if (PyErr_Occurred()) SWIG_fail;
48557 }
48558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48559 return resultobj;
48560 fail:
48561 return NULL;
48562 }
48563
48564
48565 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48566 PyObject *resultobj = 0;
48567 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48568 void *argp1 = 0 ;
48569 int res1 = 0 ;
48570 PyObject *swig_obj[1] ;
48571
48572 if (!args) SWIG_fail;
48573 swig_obj[0] = args;
48574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48575 if (!SWIG_IsOK(res1)) {
48576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48577 }
48578 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48579 {
48580 PyThreadState* __tstate = wxPyBeginAllowThreads();
48581 (arg1)->DeleteWindows();
48582 wxPyEndAllowThreads(__tstate);
48583 if (PyErr_Occurred()) SWIG_fail;
48584 }
48585 resultobj = SWIG_Py_Void();
48586 return resultobj;
48587 fail:
48588 return NULL;
48589 }
48590
48591
48592 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48593 PyObject *resultobj = 0;
48594 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48595 void *argp1 = 0 ;
48596 int res1 = 0 ;
48597 PyObject *swig_obj[1] ;
48598
48599 if (!args) SWIG_fail;
48600 swig_obj[0] = args;
48601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48602 if (!SWIG_IsOK(res1)) {
48603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48604 }
48605 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48606 {
48607 PyThreadState* __tstate = wxPyBeginAllowThreads();
48608 (arg1)->DetachSizer();
48609 wxPyEndAllowThreads(__tstate);
48610 if (PyErr_Occurred()) SWIG_fail;
48611 }
48612 resultobj = SWIG_Py_Void();
48613 return resultobj;
48614 fail:
48615 return NULL;
48616 }
48617
48618
48619 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48620 PyObject *resultobj = 0;
48621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48622 wxSize result;
48623 void *argp1 = 0 ;
48624 int res1 = 0 ;
48625 PyObject *swig_obj[1] ;
48626
48627 if (!args) SWIG_fail;
48628 swig_obj[0] = args;
48629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48630 if (!SWIG_IsOK(res1)) {
48631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48632 }
48633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48634 {
48635 PyThreadState* __tstate = wxPyBeginAllowThreads();
48636 result = (arg1)->GetSize();
48637 wxPyEndAllowThreads(__tstate);
48638 if (PyErr_Occurred()) SWIG_fail;
48639 }
48640 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48641 return resultobj;
48642 fail:
48643 return NULL;
48644 }
48645
48646
48647 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48648 PyObject *resultobj = 0;
48649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48650 wxSize result;
48651 void *argp1 = 0 ;
48652 int res1 = 0 ;
48653 PyObject *swig_obj[1] ;
48654
48655 if (!args) SWIG_fail;
48656 swig_obj[0] = args;
48657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48658 if (!SWIG_IsOK(res1)) {
48659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48660 }
48661 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48662 {
48663 PyThreadState* __tstate = wxPyBeginAllowThreads();
48664 result = (arg1)->CalcMin();
48665 wxPyEndAllowThreads(__tstate);
48666 if (PyErr_Occurred()) SWIG_fail;
48667 }
48668 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48669 return resultobj;
48670 fail:
48671 return NULL;
48672 }
48673
48674
48675 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48676 PyObject *resultobj = 0;
48677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48678 wxPoint *arg2 = 0 ;
48679 wxSize *arg3 = 0 ;
48680 void *argp1 = 0 ;
48681 int res1 = 0 ;
48682 wxPoint temp2 ;
48683 wxSize temp3 ;
48684 PyObject * obj0 = 0 ;
48685 PyObject * obj1 = 0 ;
48686 PyObject * obj2 = 0 ;
48687 char * kwnames[] = {
48688 (char *) "self",(char *) "pos",(char *) "size", NULL
48689 };
48690
48691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48693 if (!SWIG_IsOK(res1)) {
48694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48695 }
48696 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48697 {
48698 arg2 = &temp2;
48699 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48700 }
48701 {
48702 arg3 = &temp3;
48703 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48704 }
48705 {
48706 PyThreadState* __tstate = wxPyBeginAllowThreads();
48707 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48708 wxPyEndAllowThreads(__tstate);
48709 if (PyErr_Occurred()) SWIG_fail;
48710 }
48711 resultobj = SWIG_Py_Void();
48712 return resultobj;
48713 fail:
48714 return NULL;
48715 }
48716
48717
48718 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48719 PyObject *resultobj = 0;
48720 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48721 wxSize result;
48722 void *argp1 = 0 ;
48723 int res1 = 0 ;
48724 PyObject *swig_obj[1] ;
48725
48726 if (!args) SWIG_fail;
48727 swig_obj[0] = args;
48728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48729 if (!SWIG_IsOK(res1)) {
48730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48731 }
48732 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48733 {
48734 PyThreadState* __tstate = wxPyBeginAllowThreads();
48735 result = (arg1)->GetMinSize();
48736 wxPyEndAllowThreads(__tstate);
48737 if (PyErr_Occurred()) SWIG_fail;
48738 }
48739 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48740 return resultobj;
48741 fail:
48742 return NULL;
48743 }
48744
48745
48746 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48747 PyObject *resultobj = 0;
48748 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48749 wxSize result;
48750 void *argp1 = 0 ;
48751 int res1 = 0 ;
48752 PyObject *swig_obj[1] ;
48753
48754 if (!args) SWIG_fail;
48755 swig_obj[0] = args;
48756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48757 if (!SWIG_IsOK(res1)) {
48758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48759 }
48760 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48761 {
48762 PyThreadState* __tstate = wxPyBeginAllowThreads();
48763 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48764 wxPyEndAllowThreads(__tstate);
48765 if (PyErr_Occurred()) SWIG_fail;
48766 }
48767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48768 return resultobj;
48769 fail:
48770 return NULL;
48771 }
48772
48773
48774 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48775 PyObject *resultobj = 0;
48776 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48777 int arg2 ;
48778 int arg3 ;
48779 void *argp1 = 0 ;
48780 int res1 = 0 ;
48781 int val2 ;
48782 int ecode2 = 0 ;
48783 int val3 ;
48784 int ecode3 = 0 ;
48785 PyObject * obj0 = 0 ;
48786 PyObject * obj1 = 0 ;
48787 PyObject * obj2 = 0 ;
48788 char * kwnames[] = {
48789 (char *) "self",(char *) "x",(char *) "y", NULL
48790 };
48791
48792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48794 if (!SWIG_IsOK(res1)) {
48795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48796 }
48797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48798 ecode2 = SWIG_AsVal_int(obj1, &val2);
48799 if (!SWIG_IsOK(ecode2)) {
48800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48801 }
48802 arg2 = static_cast< int >(val2);
48803 ecode3 = SWIG_AsVal_int(obj2, &val3);
48804 if (!SWIG_IsOK(ecode3)) {
48805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48806 }
48807 arg3 = static_cast< int >(val3);
48808 {
48809 PyThreadState* __tstate = wxPyBeginAllowThreads();
48810 (arg1)->SetInitSize(arg2,arg3);
48811 wxPyEndAllowThreads(__tstate);
48812 if (PyErr_Occurred()) SWIG_fail;
48813 }
48814 resultobj = SWIG_Py_Void();
48815 return resultobj;
48816 fail:
48817 return NULL;
48818 }
48819
48820
48821 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48822 PyObject *resultobj = 0;
48823 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48824 int arg2 ;
48825 int arg3 ;
48826 void *argp1 = 0 ;
48827 int res1 = 0 ;
48828 int val2 ;
48829 int ecode2 = 0 ;
48830 int val3 ;
48831 int ecode3 = 0 ;
48832 PyObject * obj0 = 0 ;
48833 PyObject * obj1 = 0 ;
48834 PyObject * obj2 = 0 ;
48835 char * kwnames[] = {
48836 (char *) "self",(char *) "width",(char *) "height", NULL
48837 };
48838
48839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48841 if (!SWIG_IsOK(res1)) {
48842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48843 }
48844 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48845 ecode2 = SWIG_AsVal_int(obj1, &val2);
48846 if (!SWIG_IsOK(ecode2)) {
48847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48848 }
48849 arg2 = static_cast< int >(val2);
48850 ecode3 = SWIG_AsVal_int(obj2, &val3);
48851 if (!SWIG_IsOK(ecode3)) {
48852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48853 }
48854 arg3 = static_cast< int >(val3);
48855 {
48856 PyThreadState* __tstate = wxPyBeginAllowThreads();
48857 (arg1)->SetRatio(arg2,arg3);
48858 wxPyEndAllowThreads(__tstate);
48859 if (PyErr_Occurred()) SWIG_fail;
48860 }
48861 resultobj = SWIG_Py_Void();
48862 return resultobj;
48863 fail:
48864 return NULL;
48865 }
48866
48867
48868 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48869 PyObject *resultobj = 0;
48870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48871 wxSize *arg2 = 0 ;
48872 void *argp1 = 0 ;
48873 int res1 = 0 ;
48874 wxSize temp2 ;
48875 PyObject * obj0 = 0 ;
48876 PyObject * obj1 = 0 ;
48877 char * kwnames[] = {
48878 (char *) "self",(char *) "size", NULL
48879 };
48880
48881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48883 if (!SWIG_IsOK(res1)) {
48884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48885 }
48886 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48887 {
48888 arg2 = &temp2;
48889 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48890 }
48891 {
48892 PyThreadState* __tstate = wxPyBeginAllowThreads();
48893 (arg1)->SetRatio((wxSize const &)*arg2);
48894 wxPyEndAllowThreads(__tstate);
48895 if (PyErr_Occurred()) SWIG_fail;
48896 }
48897 resultobj = SWIG_Py_Void();
48898 return resultobj;
48899 fail:
48900 return NULL;
48901 }
48902
48903
48904 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48905 PyObject *resultobj = 0;
48906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48907 float arg2 ;
48908 void *argp1 = 0 ;
48909 int res1 = 0 ;
48910 float val2 ;
48911 int ecode2 = 0 ;
48912 PyObject * obj0 = 0 ;
48913 PyObject * obj1 = 0 ;
48914 char * kwnames[] = {
48915 (char *) "self",(char *) "ratio", NULL
48916 };
48917
48918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48920 if (!SWIG_IsOK(res1)) {
48921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48922 }
48923 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48924 ecode2 = SWIG_AsVal_float(obj1, &val2);
48925 if (!SWIG_IsOK(ecode2)) {
48926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48927 }
48928 arg2 = static_cast< float >(val2);
48929 {
48930 PyThreadState* __tstate = wxPyBeginAllowThreads();
48931 (arg1)->SetRatio(arg2);
48932 wxPyEndAllowThreads(__tstate);
48933 if (PyErr_Occurred()) SWIG_fail;
48934 }
48935 resultobj = SWIG_Py_Void();
48936 return resultobj;
48937 fail:
48938 return NULL;
48939 }
48940
48941
48942 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48943 PyObject *resultobj = 0;
48944 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48945 float result;
48946 void *argp1 = 0 ;
48947 int res1 = 0 ;
48948 PyObject *swig_obj[1] ;
48949
48950 if (!args) SWIG_fail;
48951 swig_obj[0] = args;
48952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48953 if (!SWIG_IsOK(res1)) {
48954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48955 }
48956 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48957 {
48958 PyThreadState* __tstate = wxPyBeginAllowThreads();
48959 result = (float)(arg1)->GetRatio();
48960 wxPyEndAllowThreads(__tstate);
48961 if (PyErr_Occurred()) SWIG_fail;
48962 }
48963 resultobj = SWIG_From_float(static_cast< float >(result));
48964 return resultobj;
48965 fail:
48966 return NULL;
48967 }
48968
48969
48970 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48971 PyObject *resultobj = 0;
48972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48973 wxRect result;
48974 void *argp1 = 0 ;
48975 int res1 = 0 ;
48976 PyObject *swig_obj[1] ;
48977
48978 if (!args) SWIG_fail;
48979 swig_obj[0] = args;
48980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48981 if (!SWIG_IsOK(res1)) {
48982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48983 }
48984 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48985 {
48986 PyThreadState* __tstate = wxPyBeginAllowThreads();
48987 result = (arg1)->GetRect();
48988 wxPyEndAllowThreads(__tstate);
48989 if (PyErr_Occurred()) SWIG_fail;
48990 }
48991 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
48992 return resultobj;
48993 fail:
48994 return NULL;
48995 }
48996
48997
48998 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48999 PyObject *resultobj = 0;
49000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49001 bool result;
49002 void *argp1 = 0 ;
49003 int res1 = 0 ;
49004 PyObject *swig_obj[1] ;
49005
49006 if (!args) SWIG_fail;
49007 swig_obj[0] = args;
49008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49009 if (!SWIG_IsOK(res1)) {
49010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49011 }
49012 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49013 {
49014 PyThreadState* __tstate = wxPyBeginAllowThreads();
49015 result = (bool)(arg1)->IsWindow();
49016 wxPyEndAllowThreads(__tstate);
49017 if (PyErr_Occurred()) SWIG_fail;
49018 }
49019 {
49020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49021 }
49022 return resultobj;
49023 fail:
49024 return NULL;
49025 }
49026
49027
49028 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49029 PyObject *resultobj = 0;
49030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49031 bool result;
49032 void *argp1 = 0 ;
49033 int res1 = 0 ;
49034 PyObject *swig_obj[1] ;
49035
49036 if (!args) SWIG_fail;
49037 swig_obj[0] = args;
49038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49039 if (!SWIG_IsOK(res1)) {
49040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49041 }
49042 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49043 {
49044 PyThreadState* __tstate = wxPyBeginAllowThreads();
49045 result = (bool)(arg1)->IsSizer();
49046 wxPyEndAllowThreads(__tstate);
49047 if (PyErr_Occurred()) SWIG_fail;
49048 }
49049 {
49050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49051 }
49052 return resultobj;
49053 fail:
49054 return NULL;
49055 }
49056
49057
49058 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49059 PyObject *resultobj = 0;
49060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49061 bool result;
49062 void *argp1 = 0 ;
49063 int res1 = 0 ;
49064 PyObject *swig_obj[1] ;
49065
49066 if (!args) SWIG_fail;
49067 swig_obj[0] = args;
49068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49069 if (!SWIG_IsOK(res1)) {
49070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49071 }
49072 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49073 {
49074 PyThreadState* __tstate = wxPyBeginAllowThreads();
49075 result = (bool)(arg1)->IsSpacer();
49076 wxPyEndAllowThreads(__tstate);
49077 if (PyErr_Occurred()) SWIG_fail;
49078 }
49079 {
49080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49081 }
49082 return resultobj;
49083 fail:
49084 return NULL;
49085 }
49086
49087
49088 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49089 PyObject *resultobj = 0;
49090 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49091 int arg2 ;
49092 void *argp1 = 0 ;
49093 int res1 = 0 ;
49094 int val2 ;
49095 int ecode2 = 0 ;
49096 PyObject * obj0 = 0 ;
49097 PyObject * obj1 = 0 ;
49098 char * kwnames[] = {
49099 (char *) "self",(char *) "proportion", NULL
49100 };
49101
49102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49104 if (!SWIG_IsOK(res1)) {
49105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49106 }
49107 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49108 ecode2 = SWIG_AsVal_int(obj1, &val2);
49109 if (!SWIG_IsOK(ecode2)) {
49110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49111 }
49112 arg2 = static_cast< int >(val2);
49113 {
49114 PyThreadState* __tstate = wxPyBeginAllowThreads();
49115 (arg1)->SetProportion(arg2);
49116 wxPyEndAllowThreads(__tstate);
49117 if (PyErr_Occurred()) SWIG_fail;
49118 }
49119 resultobj = SWIG_Py_Void();
49120 return resultobj;
49121 fail:
49122 return NULL;
49123 }
49124
49125
49126 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49127 PyObject *resultobj = 0;
49128 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49129 int result;
49130 void *argp1 = 0 ;
49131 int res1 = 0 ;
49132 PyObject *swig_obj[1] ;
49133
49134 if (!args) SWIG_fail;
49135 swig_obj[0] = args;
49136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49137 if (!SWIG_IsOK(res1)) {
49138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49139 }
49140 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49141 {
49142 PyThreadState* __tstate = wxPyBeginAllowThreads();
49143 result = (int)(arg1)->GetProportion();
49144 wxPyEndAllowThreads(__tstate);
49145 if (PyErr_Occurred()) SWIG_fail;
49146 }
49147 resultobj = SWIG_From_int(static_cast< int >(result));
49148 return resultobj;
49149 fail:
49150 return NULL;
49151 }
49152
49153
49154 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49155 PyObject *resultobj = 0;
49156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49157 int arg2 ;
49158 void *argp1 = 0 ;
49159 int res1 = 0 ;
49160 int val2 ;
49161 int ecode2 = 0 ;
49162 PyObject * obj0 = 0 ;
49163 PyObject * obj1 = 0 ;
49164 char * kwnames[] = {
49165 (char *) "self",(char *) "flag", NULL
49166 };
49167
49168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49170 if (!SWIG_IsOK(res1)) {
49171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49172 }
49173 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49174 ecode2 = SWIG_AsVal_int(obj1, &val2);
49175 if (!SWIG_IsOK(ecode2)) {
49176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49177 }
49178 arg2 = static_cast< int >(val2);
49179 {
49180 PyThreadState* __tstate = wxPyBeginAllowThreads();
49181 (arg1)->SetFlag(arg2);
49182 wxPyEndAllowThreads(__tstate);
49183 if (PyErr_Occurred()) SWIG_fail;
49184 }
49185 resultobj = SWIG_Py_Void();
49186 return resultobj;
49187 fail:
49188 return NULL;
49189 }
49190
49191
49192 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49193 PyObject *resultobj = 0;
49194 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49195 int result;
49196 void *argp1 = 0 ;
49197 int res1 = 0 ;
49198 PyObject *swig_obj[1] ;
49199
49200 if (!args) SWIG_fail;
49201 swig_obj[0] = args;
49202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49203 if (!SWIG_IsOK(res1)) {
49204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49205 }
49206 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49207 {
49208 PyThreadState* __tstate = wxPyBeginAllowThreads();
49209 result = (int)(arg1)->GetFlag();
49210 wxPyEndAllowThreads(__tstate);
49211 if (PyErr_Occurred()) SWIG_fail;
49212 }
49213 resultobj = SWIG_From_int(static_cast< int >(result));
49214 return resultobj;
49215 fail:
49216 return NULL;
49217 }
49218
49219
49220 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49221 PyObject *resultobj = 0;
49222 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49223 int arg2 ;
49224 void *argp1 = 0 ;
49225 int res1 = 0 ;
49226 int val2 ;
49227 int ecode2 = 0 ;
49228 PyObject * obj0 = 0 ;
49229 PyObject * obj1 = 0 ;
49230 char * kwnames[] = {
49231 (char *) "self",(char *) "border", NULL
49232 };
49233
49234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49236 if (!SWIG_IsOK(res1)) {
49237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49238 }
49239 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49240 ecode2 = SWIG_AsVal_int(obj1, &val2);
49241 if (!SWIG_IsOK(ecode2)) {
49242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49243 }
49244 arg2 = static_cast< int >(val2);
49245 {
49246 PyThreadState* __tstate = wxPyBeginAllowThreads();
49247 (arg1)->SetBorder(arg2);
49248 wxPyEndAllowThreads(__tstate);
49249 if (PyErr_Occurred()) SWIG_fail;
49250 }
49251 resultobj = SWIG_Py_Void();
49252 return resultobj;
49253 fail:
49254 return NULL;
49255 }
49256
49257
49258 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49259 PyObject *resultobj = 0;
49260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49261 int result;
49262 void *argp1 = 0 ;
49263 int res1 = 0 ;
49264 PyObject *swig_obj[1] ;
49265
49266 if (!args) SWIG_fail;
49267 swig_obj[0] = args;
49268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49269 if (!SWIG_IsOK(res1)) {
49270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49271 }
49272 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49273 {
49274 PyThreadState* __tstate = wxPyBeginAllowThreads();
49275 result = (int)(arg1)->GetBorder();
49276 wxPyEndAllowThreads(__tstate);
49277 if (PyErr_Occurred()) SWIG_fail;
49278 }
49279 resultobj = SWIG_From_int(static_cast< int >(result));
49280 return resultobj;
49281 fail:
49282 return NULL;
49283 }
49284
49285
49286 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49287 PyObject *resultobj = 0;
49288 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49289 wxWindow *result = 0 ;
49290 void *argp1 = 0 ;
49291 int res1 = 0 ;
49292 PyObject *swig_obj[1] ;
49293
49294 if (!args) SWIG_fail;
49295 swig_obj[0] = args;
49296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49297 if (!SWIG_IsOK(res1)) {
49298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49299 }
49300 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49301 {
49302 PyThreadState* __tstate = wxPyBeginAllowThreads();
49303 result = (wxWindow *)(arg1)->GetWindow();
49304 wxPyEndAllowThreads(__tstate);
49305 if (PyErr_Occurred()) SWIG_fail;
49306 }
49307 {
49308 resultobj = wxPyMake_wxObject(result, 0);
49309 }
49310 return resultobj;
49311 fail:
49312 return NULL;
49313 }
49314
49315
49316 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49317 PyObject *resultobj = 0;
49318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49319 wxWindow *arg2 = (wxWindow *) 0 ;
49320 void *argp1 = 0 ;
49321 int res1 = 0 ;
49322 void *argp2 = 0 ;
49323 int res2 = 0 ;
49324 PyObject * obj0 = 0 ;
49325 PyObject * obj1 = 0 ;
49326 char * kwnames[] = {
49327 (char *) "self",(char *) "window", NULL
49328 };
49329
49330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49332 if (!SWIG_IsOK(res1)) {
49333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49334 }
49335 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49337 if (!SWIG_IsOK(res2)) {
49338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49339 }
49340 arg2 = reinterpret_cast< wxWindow * >(argp2);
49341 {
49342 PyThreadState* __tstate = wxPyBeginAllowThreads();
49343 (arg1)->SetWindow(arg2);
49344 wxPyEndAllowThreads(__tstate);
49345 if (PyErr_Occurred()) SWIG_fail;
49346 }
49347 resultobj = SWIG_Py_Void();
49348 return resultobj;
49349 fail:
49350 return NULL;
49351 }
49352
49353
49354 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49355 PyObject *resultobj = 0;
49356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49357 wxSizer *result = 0 ;
49358 void *argp1 = 0 ;
49359 int res1 = 0 ;
49360 PyObject *swig_obj[1] ;
49361
49362 if (!args) SWIG_fail;
49363 swig_obj[0] = args;
49364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49365 if (!SWIG_IsOK(res1)) {
49366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49367 }
49368 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49369 {
49370 PyThreadState* __tstate = wxPyBeginAllowThreads();
49371 result = (wxSizer *)(arg1)->GetSizer();
49372 wxPyEndAllowThreads(__tstate);
49373 if (PyErr_Occurred()) SWIG_fail;
49374 }
49375 {
49376 resultobj = wxPyMake_wxObject(result, (bool)0);
49377 }
49378 return resultobj;
49379 fail:
49380 return NULL;
49381 }
49382
49383
49384 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49385 PyObject *resultobj = 0;
49386 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49387 wxSizer *arg2 = (wxSizer *) 0 ;
49388 void *argp1 = 0 ;
49389 int res1 = 0 ;
49390 int res2 = 0 ;
49391 PyObject * obj0 = 0 ;
49392 PyObject * obj1 = 0 ;
49393 char * kwnames[] = {
49394 (char *) "self",(char *) "sizer", NULL
49395 };
49396
49397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49399 if (!SWIG_IsOK(res1)) {
49400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49401 }
49402 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49403 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49404 if (!SWIG_IsOK(res2)) {
49405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49406 }
49407 {
49408 PyThreadState* __tstate = wxPyBeginAllowThreads();
49409 (arg1)->SetSizer(arg2);
49410 wxPyEndAllowThreads(__tstate);
49411 if (PyErr_Occurred()) SWIG_fail;
49412 }
49413 resultobj = SWIG_Py_Void();
49414 return resultobj;
49415 fail:
49416 return NULL;
49417 }
49418
49419
49420 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49421 PyObject *resultobj = 0;
49422 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49423 wxSize result;
49424 void *argp1 = 0 ;
49425 int res1 = 0 ;
49426 PyObject *swig_obj[1] ;
49427
49428 if (!args) SWIG_fail;
49429 swig_obj[0] = args;
49430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49431 if (!SWIG_IsOK(res1)) {
49432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49433 }
49434 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49435 {
49436 PyThreadState* __tstate = wxPyBeginAllowThreads();
49437 result = (arg1)->GetSpacer();
49438 wxPyEndAllowThreads(__tstate);
49439 if (PyErr_Occurred()) SWIG_fail;
49440 }
49441 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49442 return resultobj;
49443 fail:
49444 return NULL;
49445 }
49446
49447
49448 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49449 PyObject *resultobj = 0;
49450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49451 wxSize *arg2 = 0 ;
49452 void *argp1 = 0 ;
49453 int res1 = 0 ;
49454 wxSize temp2 ;
49455 PyObject * obj0 = 0 ;
49456 PyObject * obj1 = 0 ;
49457 char * kwnames[] = {
49458 (char *) "self",(char *) "size", NULL
49459 };
49460
49461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49463 if (!SWIG_IsOK(res1)) {
49464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49465 }
49466 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49467 {
49468 arg2 = &temp2;
49469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49470 }
49471 {
49472 PyThreadState* __tstate = wxPyBeginAllowThreads();
49473 (arg1)->SetSpacer((wxSize const &)*arg2);
49474 wxPyEndAllowThreads(__tstate);
49475 if (PyErr_Occurred()) SWIG_fail;
49476 }
49477 resultobj = SWIG_Py_Void();
49478 return resultobj;
49479 fail:
49480 return NULL;
49481 }
49482
49483
49484 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49485 PyObject *resultobj = 0;
49486 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49487 bool arg2 ;
49488 void *argp1 = 0 ;
49489 int res1 = 0 ;
49490 bool val2 ;
49491 int ecode2 = 0 ;
49492 PyObject * obj0 = 0 ;
49493 PyObject * obj1 = 0 ;
49494 char * kwnames[] = {
49495 (char *) "self",(char *) "show", NULL
49496 };
49497
49498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49500 if (!SWIG_IsOK(res1)) {
49501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49502 }
49503 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49504 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49505 if (!SWIG_IsOK(ecode2)) {
49506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49507 }
49508 arg2 = static_cast< bool >(val2);
49509 {
49510 PyThreadState* __tstate = wxPyBeginAllowThreads();
49511 (arg1)->Show(arg2);
49512 wxPyEndAllowThreads(__tstate);
49513 if (PyErr_Occurred()) SWIG_fail;
49514 }
49515 resultobj = SWIG_Py_Void();
49516 return resultobj;
49517 fail:
49518 return NULL;
49519 }
49520
49521
49522 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49523 PyObject *resultobj = 0;
49524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49525 bool result;
49526 void *argp1 = 0 ;
49527 int res1 = 0 ;
49528 PyObject *swig_obj[1] ;
49529
49530 if (!args) SWIG_fail;
49531 swig_obj[0] = args;
49532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49533 if (!SWIG_IsOK(res1)) {
49534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49535 }
49536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49537 {
49538 PyThreadState* __tstate = wxPyBeginAllowThreads();
49539 result = (bool)(arg1)->IsShown();
49540 wxPyEndAllowThreads(__tstate);
49541 if (PyErr_Occurred()) SWIG_fail;
49542 }
49543 {
49544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49545 }
49546 return resultobj;
49547 fail:
49548 return NULL;
49549 }
49550
49551
49552 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49553 PyObject *resultobj = 0;
49554 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49555 wxPoint result;
49556 void *argp1 = 0 ;
49557 int res1 = 0 ;
49558 PyObject *swig_obj[1] ;
49559
49560 if (!args) SWIG_fail;
49561 swig_obj[0] = args;
49562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49563 if (!SWIG_IsOK(res1)) {
49564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49565 }
49566 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49567 {
49568 PyThreadState* __tstate = wxPyBeginAllowThreads();
49569 result = (arg1)->GetPosition();
49570 wxPyEndAllowThreads(__tstate);
49571 if (PyErr_Occurred()) SWIG_fail;
49572 }
49573 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49574 return resultobj;
49575 fail:
49576 return NULL;
49577 }
49578
49579
49580 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49581 PyObject *resultobj = 0;
49582 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49583 PyObject *result = 0 ;
49584 void *argp1 = 0 ;
49585 int res1 = 0 ;
49586 PyObject *swig_obj[1] ;
49587
49588 if (!args) SWIG_fail;
49589 swig_obj[0] = args;
49590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49591 if (!SWIG_IsOK(res1)) {
49592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49593 }
49594 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49595 {
49596 PyThreadState* __tstate = wxPyBeginAllowThreads();
49597 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49598 wxPyEndAllowThreads(__tstate);
49599 if (PyErr_Occurred()) SWIG_fail;
49600 }
49601 resultobj = result;
49602 return resultobj;
49603 fail:
49604 return NULL;
49605 }
49606
49607
49608 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49609 PyObject *resultobj = 0;
49610 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49611 PyObject *arg2 = (PyObject *) 0 ;
49612 void *argp1 = 0 ;
49613 int res1 = 0 ;
49614 PyObject * obj0 = 0 ;
49615 PyObject * obj1 = 0 ;
49616 char * kwnames[] = {
49617 (char *) "self",(char *) "userData", NULL
49618 };
49619
49620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49622 if (!SWIG_IsOK(res1)) {
49623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49624 }
49625 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49626 arg2 = obj1;
49627 {
49628 PyThreadState* __tstate = wxPyBeginAllowThreads();
49629 wxSizerItem_SetUserData(arg1,arg2);
49630 wxPyEndAllowThreads(__tstate);
49631 if (PyErr_Occurred()) SWIG_fail;
49632 }
49633 resultobj = SWIG_Py_Void();
49634 return resultobj;
49635 fail:
49636 return NULL;
49637 }
49638
49639
49640 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49641 PyObject *obj;
49642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49643 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49644 return SWIG_Py_Void();
49645 }
49646
49647 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49648 return SWIG_Python_InitShadowInstance(args);
49649 }
49650
49651 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49652 PyObject *resultobj = 0;
49653 wxSizer *arg1 = (wxSizer *) 0 ;
49654 void *argp1 = 0 ;
49655 int res1 = 0 ;
49656 PyObject *swig_obj[1] ;
49657
49658 if (!args) SWIG_fail;
49659 swig_obj[0] = args;
49660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49661 if (!SWIG_IsOK(res1)) {
49662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49663 }
49664 arg1 = reinterpret_cast< wxSizer * >(argp1);
49665 {
49666 PyThreadState* __tstate = wxPyBeginAllowThreads();
49667 delete arg1;
49668
49669 wxPyEndAllowThreads(__tstate);
49670 if (PyErr_Occurred()) SWIG_fail;
49671 }
49672 resultobj = SWIG_Py_Void();
49673 return resultobj;
49674 fail:
49675 return NULL;
49676 }
49677
49678
49679 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49680 PyObject *resultobj = 0;
49681 wxSizer *arg1 = (wxSizer *) 0 ;
49682 PyObject *arg2 = (PyObject *) 0 ;
49683 void *argp1 = 0 ;
49684 int res1 = 0 ;
49685 PyObject * obj0 = 0 ;
49686 PyObject * obj1 = 0 ;
49687 char * kwnames[] = {
49688 (char *) "self",(char *) "_self", NULL
49689 };
49690
49691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49693 if (!SWIG_IsOK(res1)) {
49694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49695 }
49696 arg1 = reinterpret_cast< wxSizer * >(argp1);
49697 arg2 = obj1;
49698 {
49699 PyThreadState* __tstate = wxPyBeginAllowThreads();
49700 wxSizer__setOORInfo(arg1,arg2);
49701 wxPyEndAllowThreads(__tstate);
49702 if (PyErr_Occurred()) SWIG_fail;
49703 }
49704 resultobj = SWIG_Py_Void();
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49712 PyObject *resultobj = 0;
49713 wxSizer *arg1 = (wxSizer *) 0 ;
49714 PyObject *arg2 = (PyObject *) 0 ;
49715 int arg3 = (int) 0 ;
49716 int arg4 = (int) 0 ;
49717 int arg5 = (int) 0 ;
49718 PyObject *arg6 = (PyObject *) NULL ;
49719 wxSizerItem *result = 0 ;
49720 void *argp1 = 0 ;
49721 int res1 = 0 ;
49722 int val3 ;
49723 int ecode3 = 0 ;
49724 int val4 ;
49725 int ecode4 = 0 ;
49726 int val5 ;
49727 int ecode5 = 0 ;
49728 PyObject * obj0 = 0 ;
49729 PyObject * obj1 = 0 ;
49730 PyObject * obj2 = 0 ;
49731 PyObject * obj3 = 0 ;
49732 PyObject * obj4 = 0 ;
49733 PyObject * obj5 = 0 ;
49734 char * kwnames[] = {
49735 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49736 };
49737
49738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49740 if (!SWIG_IsOK(res1)) {
49741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49742 }
49743 arg1 = reinterpret_cast< wxSizer * >(argp1);
49744 arg2 = obj1;
49745 if (obj2) {
49746 ecode3 = SWIG_AsVal_int(obj2, &val3);
49747 if (!SWIG_IsOK(ecode3)) {
49748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49749 }
49750 arg3 = static_cast< int >(val3);
49751 }
49752 if (obj3) {
49753 ecode4 = SWIG_AsVal_int(obj3, &val4);
49754 if (!SWIG_IsOK(ecode4)) {
49755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49756 }
49757 arg4 = static_cast< int >(val4);
49758 }
49759 if (obj4) {
49760 ecode5 = SWIG_AsVal_int(obj4, &val5);
49761 if (!SWIG_IsOK(ecode5)) {
49762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49763 }
49764 arg5 = static_cast< int >(val5);
49765 }
49766 if (obj5) {
49767 arg6 = obj5;
49768 }
49769 {
49770 PyThreadState* __tstate = wxPyBeginAllowThreads();
49771 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49772 wxPyEndAllowThreads(__tstate);
49773 if (PyErr_Occurred()) SWIG_fail;
49774 }
49775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49776 return resultobj;
49777 fail:
49778 return NULL;
49779 }
49780
49781
49782 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49783 PyObject *resultobj = 0;
49784 wxSizer *arg1 = (wxSizer *) 0 ;
49785 int arg2 ;
49786 PyObject *arg3 = (PyObject *) 0 ;
49787 int arg4 = (int) 0 ;
49788 int arg5 = (int) 0 ;
49789 int arg6 = (int) 0 ;
49790 PyObject *arg7 = (PyObject *) NULL ;
49791 wxSizerItem *result = 0 ;
49792 void *argp1 = 0 ;
49793 int res1 = 0 ;
49794 int val2 ;
49795 int ecode2 = 0 ;
49796 int val4 ;
49797 int ecode4 = 0 ;
49798 int val5 ;
49799 int ecode5 = 0 ;
49800 int val6 ;
49801 int ecode6 = 0 ;
49802 PyObject * obj0 = 0 ;
49803 PyObject * obj1 = 0 ;
49804 PyObject * obj2 = 0 ;
49805 PyObject * obj3 = 0 ;
49806 PyObject * obj4 = 0 ;
49807 PyObject * obj5 = 0 ;
49808 PyObject * obj6 = 0 ;
49809 char * kwnames[] = {
49810 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49811 };
49812
49813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49815 if (!SWIG_IsOK(res1)) {
49816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49817 }
49818 arg1 = reinterpret_cast< wxSizer * >(argp1);
49819 ecode2 = SWIG_AsVal_int(obj1, &val2);
49820 if (!SWIG_IsOK(ecode2)) {
49821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49822 }
49823 arg2 = static_cast< int >(val2);
49824 arg3 = obj2;
49825 if (obj3) {
49826 ecode4 = SWIG_AsVal_int(obj3, &val4);
49827 if (!SWIG_IsOK(ecode4)) {
49828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49829 }
49830 arg4 = static_cast< int >(val4);
49831 }
49832 if (obj4) {
49833 ecode5 = SWIG_AsVal_int(obj4, &val5);
49834 if (!SWIG_IsOK(ecode5)) {
49835 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49836 }
49837 arg5 = static_cast< int >(val5);
49838 }
49839 if (obj5) {
49840 ecode6 = SWIG_AsVal_int(obj5, &val6);
49841 if (!SWIG_IsOK(ecode6)) {
49842 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49843 }
49844 arg6 = static_cast< int >(val6);
49845 }
49846 if (obj6) {
49847 arg7 = obj6;
49848 }
49849 {
49850 PyThreadState* __tstate = wxPyBeginAllowThreads();
49851 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49852 wxPyEndAllowThreads(__tstate);
49853 if (PyErr_Occurred()) SWIG_fail;
49854 }
49855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49856 return resultobj;
49857 fail:
49858 return NULL;
49859 }
49860
49861
49862 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49863 PyObject *resultobj = 0;
49864 wxSizer *arg1 = (wxSizer *) 0 ;
49865 PyObject *arg2 = (PyObject *) 0 ;
49866 int arg3 = (int) 0 ;
49867 int arg4 = (int) 0 ;
49868 int arg5 = (int) 0 ;
49869 PyObject *arg6 = (PyObject *) NULL ;
49870 wxSizerItem *result = 0 ;
49871 void *argp1 = 0 ;
49872 int res1 = 0 ;
49873 int val3 ;
49874 int ecode3 = 0 ;
49875 int val4 ;
49876 int ecode4 = 0 ;
49877 int val5 ;
49878 int ecode5 = 0 ;
49879 PyObject * obj0 = 0 ;
49880 PyObject * obj1 = 0 ;
49881 PyObject * obj2 = 0 ;
49882 PyObject * obj3 = 0 ;
49883 PyObject * obj4 = 0 ;
49884 PyObject * obj5 = 0 ;
49885 char * kwnames[] = {
49886 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49887 };
49888
49889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49891 if (!SWIG_IsOK(res1)) {
49892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49893 }
49894 arg1 = reinterpret_cast< wxSizer * >(argp1);
49895 arg2 = obj1;
49896 if (obj2) {
49897 ecode3 = SWIG_AsVal_int(obj2, &val3);
49898 if (!SWIG_IsOK(ecode3)) {
49899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49900 }
49901 arg3 = static_cast< int >(val3);
49902 }
49903 if (obj3) {
49904 ecode4 = SWIG_AsVal_int(obj3, &val4);
49905 if (!SWIG_IsOK(ecode4)) {
49906 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49907 }
49908 arg4 = static_cast< int >(val4);
49909 }
49910 if (obj4) {
49911 ecode5 = SWIG_AsVal_int(obj4, &val5);
49912 if (!SWIG_IsOK(ecode5)) {
49913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49914 }
49915 arg5 = static_cast< int >(val5);
49916 }
49917 if (obj5) {
49918 arg6 = obj5;
49919 }
49920 {
49921 PyThreadState* __tstate = wxPyBeginAllowThreads();
49922 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49923 wxPyEndAllowThreads(__tstate);
49924 if (PyErr_Occurred()) SWIG_fail;
49925 }
49926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49927 return resultobj;
49928 fail:
49929 return NULL;
49930 }
49931
49932
49933 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49934 PyObject *resultobj = 0;
49935 wxSizer *arg1 = (wxSizer *) 0 ;
49936 PyObject *arg2 = (PyObject *) 0 ;
49937 bool result;
49938 void *argp1 = 0 ;
49939 int res1 = 0 ;
49940 PyObject * obj0 = 0 ;
49941 PyObject * obj1 = 0 ;
49942 char * kwnames[] = {
49943 (char *) "self",(char *) "item", NULL
49944 };
49945
49946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49948 if (!SWIG_IsOK(res1)) {
49949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49950 }
49951 arg1 = reinterpret_cast< wxSizer * >(argp1);
49952 arg2 = obj1;
49953 {
49954 PyThreadState* __tstate = wxPyBeginAllowThreads();
49955 result = (bool)wxSizer_Remove(arg1,arg2);
49956 wxPyEndAllowThreads(__tstate);
49957 if (PyErr_Occurred()) SWIG_fail;
49958 }
49959 {
49960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49961 }
49962 return resultobj;
49963 fail:
49964 return NULL;
49965 }
49966
49967
49968 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49969 PyObject *resultobj = 0;
49970 wxSizer *arg1 = (wxSizer *) 0 ;
49971 PyObject *arg2 = (PyObject *) 0 ;
49972 bool result;
49973 void *argp1 = 0 ;
49974 int res1 = 0 ;
49975 PyObject * obj0 = 0 ;
49976 PyObject * obj1 = 0 ;
49977 char * kwnames[] = {
49978 (char *) "self",(char *) "item", NULL
49979 };
49980
49981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49983 if (!SWIG_IsOK(res1)) {
49984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
49985 }
49986 arg1 = reinterpret_cast< wxSizer * >(argp1);
49987 arg2 = obj1;
49988 {
49989 PyThreadState* __tstate = wxPyBeginAllowThreads();
49990 result = (bool)wxSizer_Detach(arg1,arg2);
49991 wxPyEndAllowThreads(__tstate);
49992 if (PyErr_Occurred()) SWIG_fail;
49993 }
49994 {
49995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49996 }
49997 return resultobj;
49998 fail:
49999 return NULL;
50000 }
50001
50002
50003 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50004 PyObject *resultobj = 0;
50005 wxSizer *arg1 = (wxSizer *) 0 ;
50006 PyObject *arg2 = (PyObject *) 0 ;
50007 wxSizerItem *result = 0 ;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 PyObject * obj0 = 0 ;
50011 PyObject * obj1 = 0 ;
50012 char * kwnames[] = {
50013 (char *) "self",(char *) "item", NULL
50014 };
50015
50016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50018 if (!SWIG_IsOK(res1)) {
50019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50020 }
50021 arg1 = reinterpret_cast< wxSizer * >(argp1);
50022 arg2 = obj1;
50023 {
50024 PyThreadState* __tstate = wxPyBeginAllowThreads();
50025 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50026 wxPyEndAllowThreads(__tstate);
50027 if (PyErr_Occurred()) SWIG_fail;
50028 }
50029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50030 return resultobj;
50031 fail:
50032 return NULL;
50033 }
50034
50035
50036 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50037 PyObject *resultobj = 0;
50038 wxSizer *arg1 = (wxSizer *) 0 ;
50039 PyObject *arg2 = (PyObject *) 0 ;
50040 wxSize *arg3 = 0 ;
50041 void *argp1 = 0 ;
50042 int res1 = 0 ;
50043 wxSize temp3 ;
50044 PyObject * obj0 = 0 ;
50045 PyObject * obj1 = 0 ;
50046 PyObject * obj2 = 0 ;
50047 char * kwnames[] = {
50048 (char *) "self",(char *) "item",(char *) "size", NULL
50049 };
50050
50051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50053 if (!SWIG_IsOK(res1)) {
50054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50055 }
50056 arg1 = reinterpret_cast< wxSizer * >(argp1);
50057 arg2 = obj1;
50058 {
50059 arg3 = &temp3;
50060 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50061 }
50062 {
50063 PyThreadState* __tstate = wxPyBeginAllowThreads();
50064 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50065 wxPyEndAllowThreads(__tstate);
50066 if (PyErr_Occurred()) SWIG_fail;
50067 }
50068 resultobj = SWIG_Py_Void();
50069 return resultobj;
50070 fail:
50071 return NULL;
50072 }
50073
50074
50075 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50076 PyObject *resultobj = 0;
50077 wxSizer *arg1 = (wxSizer *) 0 ;
50078 wxWindow *arg2 = (wxWindow *) 0 ;
50079 wxWindow *arg3 = (wxWindow *) 0 ;
50080 bool arg4 = (bool) false ;
50081 bool result;
50082 void *argp1 = 0 ;
50083 int res1 = 0 ;
50084 void *argp2 = 0 ;
50085 int res2 = 0 ;
50086 void *argp3 = 0 ;
50087 int res3 = 0 ;
50088 bool val4 ;
50089 int ecode4 = 0 ;
50090 PyObject * obj0 = 0 ;
50091 PyObject * obj1 = 0 ;
50092 PyObject * obj2 = 0 ;
50093 PyObject * obj3 = 0 ;
50094 char * kwnames[] = {
50095 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50096 };
50097
50098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50100 if (!SWIG_IsOK(res1)) {
50101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50102 }
50103 arg1 = reinterpret_cast< wxSizer * >(argp1);
50104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50105 if (!SWIG_IsOK(res2)) {
50106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50107 }
50108 arg2 = reinterpret_cast< wxWindow * >(argp2);
50109 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50110 if (!SWIG_IsOK(res3)) {
50111 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50112 }
50113 arg3 = reinterpret_cast< wxWindow * >(argp3);
50114 if (obj3) {
50115 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50116 if (!SWIG_IsOK(ecode4)) {
50117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50118 }
50119 arg4 = static_cast< bool >(val4);
50120 }
50121 {
50122 PyThreadState* __tstate = wxPyBeginAllowThreads();
50123 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50124 wxPyEndAllowThreads(__tstate);
50125 if (PyErr_Occurred()) SWIG_fail;
50126 }
50127 {
50128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50129 }
50130 return resultobj;
50131 fail:
50132 return NULL;
50133 }
50134
50135
50136 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50137 PyObject *resultobj = 0;
50138 wxSizer *arg1 = (wxSizer *) 0 ;
50139 wxSizer *arg2 = (wxSizer *) 0 ;
50140 wxSizer *arg3 = (wxSizer *) 0 ;
50141 bool arg4 = (bool) false ;
50142 bool result;
50143 void *argp1 = 0 ;
50144 int res1 = 0 ;
50145 void *argp2 = 0 ;
50146 int res2 = 0 ;
50147 void *argp3 = 0 ;
50148 int res3 = 0 ;
50149 bool val4 ;
50150 int ecode4 = 0 ;
50151 PyObject * obj0 = 0 ;
50152 PyObject * obj1 = 0 ;
50153 PyObject * obj2 = 0 ;
50154 PyObject * obj3 = 0 ;
50155 char * kwnames[] = {
50156 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50157 };
50158
50159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50161 if (!SWIG_IsOK(res1)) {
50162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50163 }
50164 arg1 = reinterpret_cast< wxSizer * >(argp1);
50165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50166 if (!SWIG_IsOK(res2)) {
50167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50168 }
50169 arg2 = reinterpret_cast< wxSizer * >(argp2);
50170 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50171 if (!SWIG_IsOK(res3)) {
50172 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50173 }
50174 arg3 = reinterpret_cast< wxSizer * >(argp3);
50175 if (obj3) {
50176 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50177 if (!SWIG_IsOK(ecode4)) {
50178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50179 }
50180 arg4 = static_cast< bool >(val4);
50181 }
50182 {
50183 PyThreadState* __tstate = wxPyBeginAllowThreads();
50184 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50185 wxPyEndAllowThreads(__tstate);
50186 if (PyErr_Occurred()) SWIG_fail;
50187 }
50188 {
50189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50190 }
50191 return resultobj;
50192 fail:
50193 return NULL;
50194 }
50195
50196
50197 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50198 PyObject *resultobj = 0;
50199 wxSizer *arg1 = (wxSizer *) 0 ;
50200 size_t arg2 ;
50201 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50202 bool result;
50203 void *argp1 = 0 ;
50204 int res1 = 0 ;
50205 size_t val2 ;
50206 int ecode2 = 0 ;
50207 void *argp3 = 0 ;
50208 int res3 = 0 ;
50209 PyObject * obj0 = 0 ;
50210 PyObject * obj1 = 0 ;
50211 PyObject * obj2 = 0 ;
50212 char * kwnames[] = {
50213 (char *) "self",(char *) "index",(char *) "newitem", NULL
50214 };
50215
50216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50218 if (!SWIG_IsOK(res1)) {
50219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50220 }
50221 arg1 = reinterpret_cast< wxSizer * >(argp1);
50222 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50223 if (!SWIG_IsOK(ecode2)) {
50224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50225 }
50226 arg2 = static_cast< size_t >(val2);
50227 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50228 if (!SWIG_IsOK(res3)) {
50229 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50230 }
50231 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50232 {
50233 PyThreadState* __tstate = wxPyBeginAllowThreads();
50234 result = (bool)(arg1)->Replace(arg2,arg3);
50235 wxPyEndAllowThreads(__tstate);
50236 if (PyErr_Occurred()) SWIG_fail;
50237 }
50238 {
50239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50240 }
50241 return resultobj;
50242 fail:
50243 return NULL;
50244 }
50245
50246
50247 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50248 PyObject *resultobj = 0;
50249 wxSizer *arg1 = (wxSizer *) 0 ;
50250 wxWindow *arg2 = (wxWindow *) 0 ;
50251 void *argp1 = 0 ;
50252 int res1 = 0 ;
50253 void *argp2 = 0 ;
50254 int res2 = 0 ;
50255 PyObject * obj0 = 0 ;
50256 PyObject * obj1 = 0 ;
50257 char * kwnames[] = {
50258 (char *) "self",(char *) "window", NULL
50259 };
50260
50261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50263 if (!SWIG_IsOK(res1)) {
50264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50265 }
50266 arg1 = reinterpret_cast< wxSizer * >(argp1);
50267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50268 if (!SWIG_IsOK(res2)) {
50269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50270 }
50271 arg2 = reinterpret_cast< wxWindow * >(argp2);
50272 {
50273 PyThreadState* __tstate = wxPyBeginAllowThreads();
50274 (arg1)->SetContainingWindow(arg2);
50275 wxPyEndAllowThreads(__tstate);
50276 if (PyErr_Occurred()) SWIG_fail;
50277 }
50278 resultobj = SWIG_Py_Void();
50279 return resultobj;
50280 fail:
50281 return NULL;
50282 }
50283
50284
50285 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50286 PyObject *resultobj = 0;
50287 wxSizer *arg1 = (wxSizer *) 0 ;
50288 wxWindow *result = 0 ;
50289 void *argp1 = 0 ;
50290 int res1 = 0 ;
50291 PyObject *swig_obj[1] ;
50292
50293 if (!args) SWIG_fail;
50294 swig_obj[0] = args;
50295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50296 if (!SWIG_IsOK(res1)) {
50297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50298 }
50299 arg1 = reinterpret_cast< wxSizer * >(argp1);
50300 {
50301 PyThreadState* __tstate = wxPyBeginAllowThreads();
50302 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50303 wxPyEndAllowThreads(__tstate);
50304 if (PyErr_Occurred()) SWIG_fail;
50305 }
50306 {
50307 resultobj = wxPyMake_wxObject(result, 0);
50308 }
50309 return resultobj;
50310 fail:
50311 return NULL;
50312 }
50313
50314
50315 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50316 PyObject *resultobj = 0;
50317 wxSizer *arg1 = (wxSizer *) 0 ;
50318 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50319 wxSizerItem *result = 0 ;
50320 void *argp1 = 0 ;
50321 int res1 = 0 ;
50322 int res2 = 0 ;
50323 PyObject * obj0 = 0 ;
50324 PyObject * obj1 = 0 ;
50325 char * kwnames[] = {
50326 (char *) "self",(char *) "item", NULL
50327 };
50328
50329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50331 if (!SWIG_IsOK(res1)) {
50332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50333 }
50334 arg1 = reinterpret_cast< wxSizer * >(argp1);
50335 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50336 if (!SWIG_IsOK(res2)) {
50337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50338 }
50339 {
50340 PyThreadState* __tstate = wxPyBeginAllowThreads();
50341 result = (wxSizerItem *)(arg1)->Add(arg2);
50342 wxPyEndAllowThreads(__tstate);
50343 if (PyErr_Occurred()) SWIG_fail;
50344 }
50345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50346 return resultobj;
50347 fail:
50348 return NULL;
50349 }
50350
50351
50352 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50353 PyObject *resultobj = 0;
50354 wxSizer *arg1 = (wxSizer *) 0 ;
50355 size_t arg2 ;
50356 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50357 wxSizerItem *result = 0 ;
50358 void *argp1 = 0 ;
50359 int res1 = 0 ;
50360 size_t val2 ;
50361 int ecode2 = 0 ;
50362 int res3 = 0 ;
50363 PyObject * obj0 = 0 ;
50364 PyObject * obj1 = 0 ;
50365 PyObject * obj2 = 0 ;
50366 char * kwnames[] = {
50367 (char *) "self",(char *) "index",(char *) "item", NULL
50368 };
50369
50370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50372 if (!SWIG_IsOK(res1)) {
50373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50374 }
50375 arg1 = reinterpret_cast< wxSizer * >(argp1);
50376 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50377 if (!SWIG_IsOK(ecode2)) {
50378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50379 }
50380 arg2 = static_cast< size_t >(val2);
50381 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50382 if (!SWIG_IsOK(res3)) {
50383 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50384 }
50385 {
50386 PyThreadState* __tstate = wxPyBeginAllowThreads();
50387 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50388 wxPyEndAllowThreads(__tstate);
50389 if (PyErr_Occurred()) SWIG_fail;
50390 }
50391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50392 return resultobj;
50393 fail:
50394 return NULL;
50395 }
50396
50397
50398 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50399 PyObject *resultobj = 0;
50400 wxSizer *arg1 = (wxSizer *) 0 ;
50401 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50402 wxSizerItem *result = 0 ;
50403 void *argp1 = 0 ;
50404 int res1 = 0 ;
50405 int res2 = 0 ;
50406 PyObject * obj0 = 0 ;
50407 PyObject * obj1 = 0 ;
50408 char * kwnames[] = {
50409 (char *) "self",(char *) "item", NULL
50410 };
50411
50412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50414 if (!SWIG_IsOK(res1)) {
50415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50416 }
50417 arg1 = reinterpret_cast< wxSizer * >(argp1);
50418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50419 if (!SWIG_IsOK(res2)) {
50420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50421 }
50422 {
50423 PyThreadState* __tstate = wxPyBeginAllowThreads();
50424 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50425 wxPyEndAllowThreads(__tstate);
50426 if (PyErr_Occurred()) SWIG_fail;
50427 }
50428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50429 return resultobj;
50430 fail:
50431 return NULL;
50432 }
50433
50434
50435 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50436 PyObject *resultobj = 0;
50437 wxSizer *arg1 = (wxSizer *) 0 ;
50438 int arg2 ;
50439 int arg3 ;
50440 int arg4 ;
50441 int arg5 ;
50442 void *argp1 = 0 ;
50443 int res1 = 0 ;
50444 int val2 ;
50445 int ecode2 = 0 ;
50446 int val3 ;
50447 int ecode3 = 0 ;
50448 int val4 ;
50449 int ecode4 = 0 ;
50450 int val5 ;
50451 int ecode5 = 0 ;
50452 PyObject * obj0 = 0 ;
50453 PyObject * obj1 = 0 ;
50454 PyObject * obj2 = 0 ;
50455 PyObject * obj3 = 0 ;
50456 PyObject * obj4 = 0 ;
50457 char * kwnames[] = {
50458 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50459 };
50460
50461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50463 if (!SWIG_IsOK(res1)) {
50464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50465 }
50466 arg1 = reinterpret_cast< wxSizer * >(argp1);
50467 ecode2 = SWIG_AsVal_int(obj1, &val2);
50468 if (!SWIG_IsOK(ecode2)) {
50469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50470 }
50471 arg2 = static_cast< int >(val2);
50472 ecode3 = SWIG_AsVal_int(obj2, &val3);
50473 if (!SWIG_IsOK(ecode3)) {
50474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50475 }
50476 arg3 = static_cast< int >(val3);
50477 ecode4 = SWIG_AsVal_int(obj3, &val4);
50478 if (!SWIG_IsOK(ecode4)) {
50479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50480 }
50481 arg4 = static_cast< int >(val4);
50482 ecode5 = SWIG_AsVal_int(obj4, &val5);
50483 if (!SWIG_IsOK(ecode5)) {
50484 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50485 }
50486 arg5 = static_cast< int >(val5);
50487 {
50488 PyThreadState* __tstate = wxPyBeginAllowThreads();
50489 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50490 wxPyEndAllowThreads(__tstate);
50491 if (PyErr_Occurred()) SWIG_fail;
50492 }
50493 resultobj = SWIG_Py_Void();
50494 return resultobj;
50495 fail:
50496 return NULL;
50497 }
50498
50499
50500 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50501 PyObject *resultobj = 0;
50502 wxSizer *arg1 = (wxSizer *) 0 ;
50503 wxSize *arg2 = 0 ;
50504 void *argp1 = 0 ;
50505 int res1 = 0 ;
50506 wxSize temp2 ;
50507 PyObject * obj0 = 0 ;
50508 PyObject * obj1 = 0 ;
50509 char * kwnames[] = {
50510 (char *) "self",(char *) "size", NULL
50511 };
50512
50513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50515 if (!SWIG_IsOK(res1)) {
50516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50517 }
50518 arg1 = reinterpret_cast< wxSizer * >(argp1);
50519 {
50520 arg2 = &temp2;
50521 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50522 }
50523 {
50524 PyThreadState* __tstate = wxPyBeginAllowThreads();
50525 (arg1)->SetMinSize((wxSize const &)*arg2);
50526 wxPyEndAllowThreads(__tstate);
50527 if (PyErr_Occurred()) SWIG_fail;
50528 }
50529 resultobj = SWIG_Py_Void();
50530 return resultobj;
50531 fail:
50532 return NULL;
50533 }
50534
50535
50536 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50537 PyObject *resultobj = 0;
50538 wxSizer *arg1 = (wxSizer *) 0 ;
50539 wxSize result;
50540 void *argp1 = 0 ;
50541 int res1 = 0 ;
50542 PyObject *swig_obj[1] ;
50543
50544 if (!args) SWIG_fail;
50545 swig_obj[0] = args;
50546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50547 if (!SWIG_IsOK(res1)) {
50548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50549 }
50550 arg1 = reinterpret_cast< wxSizer * >(argp1);
50551 {
50552 PyThreadState* __tstate = wxPyBeginAllowThreads();
50553 result = (arg1)->GetSize();
50554 wxPyEndAllowThreads(__tstate);
50555 if (PyErr_Occurred()) SWIG_fail;
50556 }
50557 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50558 return resultobj;
50559 fail:
50560 return NULL;
50561 }
50562
50563
50564 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50565 PyObject *resultobj = 0;
50566 wxSizer *arg1 = (wxSizer *) 0 ;
50567 wxPoint result;
50568 void *argp1 = 0 ;
50569 int res1 = 0 ;
50570 PyObject *swig_obj[1] ;
50571
50572 if (!args) SWIG_fail;
50573 swig_obj[0] = args;
50574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50575 if (!SWIG_IsOK(res1)) {
50576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50577 }
50578 arg1 = reinterpret_cast< wxSizer * >(argp1);
50579 {
50580 PyThreadState* __tstate = wxPyBeginAllowThreads();
50581 result = (arg1)->GetPosition();
50582 wxPyEndAllowThreads(__tstate);
50583 if (PyErr_Occurred()) SWIG_fail;
50584 }
50585 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50586 return resultobj;
50587 fail:
50588 return NULL;
50589 }
50590
50591
50592 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50593 PyObject *resultobj = 0;
50594 wxSizer *arg1 = (wxSizer *) 0 ;
50595 wxSize result;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 PyObject *swig_obj[1] ;
50599
50600 if (!args) SWIG_fail;
50601 swig_obj[0] = args;
50602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50603 if (!SWIG_IsOK(res1)) {
50604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50605 }
50606 arg1 = reinterpret_cast< wxSizer * >(argp1);
50607 {
50608 PyThreadState* __tstate = wxPyBeginAllowThreads();
50609 result = (arg1)->GetMinSize();
50610 wxPyEndAllowThreads(__tstate);
50611 if (PyErr_Occurred()) SWIG_fail;
50612 }
50613 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50614 return resultobj;
50615 fail:
50616 return NULL;
50617 }
50618
50619
50620 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50621 PyObject *resultobj = 0;
50622 wxSizer *arg1 = (wxSizer *) 0 ;
50623 void *argp1 = 0 ;
50624 int res1 = 0 ;
50625 PyObject *swig_obj[1] ;
50626
50627 if (!args) SWIG_fail;
50628 swig_obj[0] = args;
50629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50630 if (!SWIG_IsOK(res1)) {
50631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50632 }
50633 arg1 = reinterpret_cast< wxSizer * >(argp1);
50634 {
50635 PyThreadState* __tstate = wxPyBeginAllowThreads();
50636 (arg1)->RecalcSizes();
50637 wxPyEndAllowThreads(__tstate);
50638 if (PyErr_Occurred()) SWIG_fail;
50639 }
50640 resultobj = SWIG_Py_Void();
50641 return resultobj;
50642 fail:
50643 return NULL;
50644 }
50645
50646
50647 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50648 PyObject *resultobj = 0;
50649 wxSizer *arg1 = (wxSizer *) 0 ;
50650 wxSize result;
50651 void *argp1 = 0 ;
50652 int res1 = 0 ;
50653 PyObject *swig_obj[1] ;
50654
50655 if (!args) SWIG_fail;
50656 swig_obj[0] = args;
50657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50658 if (!SWIG_IsOK(res1)) {
50659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50660 }
50661 arg1 = reinterpret_cast< wxSizer * >(argp1);
50662 {
50663 PyThreadState* __tstate = wxPyBeginAllowThreads();
50664 result = (arg1)->CalcMin();
50665 wxPyEndAllowThreads(__tstate);
50666 if (PyErr_Occurred()) SWIG_fail;
50667 }
50668 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50669 return resultobj;
50670 fail:
50671 return NULL;
50672 }
50673
50674
50675 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50676 PyObject *resultobj = 0;
50677 wxSizer *arg1 = (wxSizer *) 0 ;
50678 void *argp1 = 0 ;
50679 int res1 = 0 ;
50680 PyObject *swig_obj[1] ;
50681
50682 if (!args) SWIG_fail;
50683 swig_obj[0] = args;
50684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50685 if (!SWIG_IsOK(res1)) {
50686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50687 }
50688 arg1 = reinterpret_cast< wxSizer * >(argp1);
50689 {
50690 PyThreadState* __tstate = wxPyBeginAllowThreads();
50691 (arg1)->Layout();
50692 wxPyEndAllowThreads(__tstate);
50693 if (PyErr_Occurred()) SWIG_fail;
50694 }
50695 resultobj = SWIG_Py_Void();
50696 return resultobj;
50697 fail:
50698 return NULL;
50699 }
50700
50701
50702 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50703 PyObject *resultobj = 0;
50704 wxSizer *arg1 = (wxSizer *) 0 ;
50705 wxWindow *arg2 = (wxWindow *) 0 ;
50706 wxSize result;
50707 void *argp1 = 0 ;
50708 int res1 = 0 ;
50709 void *argp2 = 0 ;
50710 int res2 = 0 ;
50711 PyObject * obj0 = 0 ;
50712 PyObject * obj1 = 0 ;
50713 char * kwnames[] = {
50714 (char *) "self",(char *) "window", NULL
50715 };
50716
50717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50719 if (!SWIG_IsOK(res1)) {
50720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50721 }
50722 arg1 = reinterpret_cast< wxSizer * >(argp1);
50723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50724 if (!SWIG_IsOK(res2)) {
50725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50726 }
50727 arg2 = reinterpret_cast< wxWindow * >(argp2);
50728 {
50729 PyThreadState* __tstate = wxPyBeginAllowThreads();
50730 result = (arg1)->Fit(arg2);
50731 wxPyEndAllowThreads(__tstate);
50732 if (PyErr_Occurred()) SWIG_fail;
50733 }
50734 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50735 return resultobj;
50736 fail:
50737 return NULL;
50738 }
50739
50740
50741 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50742 PyObject *resultobj = 0;
50743 wxSizer *arg1 = (wxSizer *) 0 ;
50744 wxWindow *arg2 = (wxWindow *) 0 ;
50745 void *argp1 = 0 ;
50746 int res1 = 0 ;
50747 void *argp2 = 0 ;
50748 int res2 = 0 ;
50749 PyObject * obj0 = 0 ;
50750 PyObject * obj1 = 0 ;
50751 char * kwnames[] = {
50752 (char *) "self",(char *) "window", NULL
50753 };
50754
50755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50757 if (!SWIG_IsOK(res1)) {
50758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50759 }
50760 arg1 = reinterpret_cast< wxSizer * >(argp1);
50761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50762 if (!SWIG_IsOK(res2)) {
50763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50764 }
50765 arg2 = reinterpret_cast< wxWindow * >(argp2);
50766 {
50767 PyThreadState* __tstate = wxPyBeginAllowThreads();
50768 (arg1)->FitInside(arg2);
50769 wxPyEndAllowThreads(__tstate);
50770 if (PyErr_Occurred()) SWIG_fail;
50771 }
50772 resultobj = SWIG_Py_Void();
50773 return resultobj;
50774 fail:
50775 return NULL;
50776 }
50777
50778
50779 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50780 PyObject *resultobj = 0;
50781 wxSizer *arg1 = (wxSizer *) 0 ;
50782 wxWindow *arg2 = (wxWindow *) 0 ;
50783 void *argp1 = 0 ;
50784 int res1 = 0 ;
50785 void *argp2 = 0 ;
50786 int res2 = 0 ;
50787 PyObject * obj0 = 0 ;
50788 PyObject * obj1 = 0 ;
50789 char * kwnames[] = {
50790 (char *) "self",(char *) "window", NULL
50791 };
50792
50793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50795 if (!SWIG_IsOK(res1)) {
50796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50797 }
50798 arg1 = reinterpret_cast< wxSizer * >(argp1);
50799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50800 if (!SWIG_IsOK(res2)) {
50801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50802 }
50803 arg2 = reinterpret_cast< wxWindow * >(argp2);
50804 {
50805 PyThreadState* __tstate = wxPyBeginAllowThreads();
50806 (arg1)->SetSizeHints(arg2);
50807 wxPyEndAllowThreads(__tstate);
50808 if (PyErr_Occurred()) SWIG_fail;
50809 }
50810 resultobj = SWIG_Py_Void();
50811 return resultobj;
50812 fail:
50813 return NULL;
50814 }
50815
50816
50817 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50818 PyObject *resultobj = 0;
50819 wxSizer *arg1 = (wxSizer *) 0 ;
50820 wxWindow *arg2 = (wxWindow *) 0 ;
50821 void *argp1 = 0 ;
50822 int res1 = 0 ;
50823 void *argp2 = 0 ;
50824 int res2 = 0 ;
50825 PyObject * obj0 = 0 ;
50826 PyObject * obj1 = 0 ;
50827 char * kwnames[] = {
50828 (char *) "self",(char *) "window", NULL
50829 };
50830
50831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50833 if (!SWIG_IsOK(res1)) {
50834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50835 }
50836 arg1 = reinterpret_cast< wxSizer * >(argp1);
50837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50838 if (!SWIG_IsOK(res2)) {
50839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50840 }
50841 arg2 = reinterpret_cast< wxWindow * >(argp2);
50842 {
50843 PyThreadState* __tstate = wxPyBeginAllowThreads();
50844 (arg1)->SetVirtualSizeHints(arg2);
50845 wxPyEndAllowThreads(__tstate);
50846 if (PyErr_Occurred()) SWIG_fail;
50847 }
50848 resultobj = SWIG_Py_Void();
50849 return resultobj;
50850 fail:
50851 return NULL;
50852 }
50853
50854
50855 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50856 PyObject *resultobj = 0;
50857 wxSizer *arg1 = (wxSizer *) 0 ;
50858 bool arg2 = (bool) false ;
50859 void *argp1 = 0 ;
50860 int res1 = 0 ;
50861 bool val2 ;
50862 int ecode2 = 0 ;
50863 PyObject * obj0 = 0 ;
50864 PyObject * obj1 = 0 ;
50865 char * kwnames[] = {
50866 (char *) "self",(char *) "deleteWindows", NULL
50867 };
50868
50869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50871 if (!SWIG_IsOK(res1)) {
50872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50873 }
50874 arg1 = reinterpret_cast< wxSizer * >(argp1);
50875 if (obj1) {
50876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50877 if (!SWIG_IsOK(ecode2)) {
50878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50879 }
50880 arg2 = static_cast< bool >(val2);
50881 }
50882 {
50883 PyThreadState* __tstate = wxPyBeginAllowThreads();
50884 (arg1)->Clear(arg2);
50885 wxPyEndAllowThreads(__tstate);
50886 if (PyErr_Occurred()) SWIG_fail;
50887 }
50888 resultobj = SWIG_Py_Void();
50889 return resultobj;
50890 fail:
50891 return NULL;
50892 }
50893
50894
50895 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50896 PyObject *resultobj = 0;
50897 wxSizer *arg1 = (wxSizer *) 0 ;
50898 void *argp1 = 0 ;
50899 int res1 = 0 ;
50900 PyObject *swig_obj[1] ;
50901
50902 if (!args) SWIG_fail;
50903 swig_obj[0] = args;
50904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50907 }
50908 arg1 = reinterpret_cast< wxSizer * >(argp1);
50909 {
50910 PyThreadState* __tstate = wxPyBeginAllowThreads();
50911 (arg1)->DeleteWindows();
50912 wxPyEndAllowThreads(__tstate);
50913 if (PyErr_Occurred()) SWIG_fail;
50914 }
50915 resultobj = SWIG_Py_Void();
50916 return resultobj;
50917 fail:
50918 return NULL;
50919 }
50920
50921
50922 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50923 PyObject *resultobj = 0;
50924 wxSizer *arg1 = (wxSizer *) 0 ;
50925 PyObject *result = 0 ;
50926 void *argp1 = 0 ;
50927 int res1 = 0 ;
50928 PyObject *swig_obj[1] ;
50929
50930 if (!args) SWIG_fail;
50931 swig_obj[0] = args;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50935 }
50936 arg1 = reinterpret_cast< wxSizer * >(argp1);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (PyObject *)wxSizer_GetChildren(arg1);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = result;
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxSizer *arg1 = (wxSizer *) 0 ;
50953 PyObject *arg2 = (PyObject *) 0 ;
50954 bool arg3 = (bool) true ;
50955 bool arg4 = (bool) false ;
50956 bool result;
50957 void *argp1 = 0 ;
50958 int res1 = 0 ;
50959 bool val3 ;
50960 int ecode3 = 0 ;
50961 bool val4 ;
50962 int ecode4 = 0 ;
50963 PyObject * obj0 = 0 ;
50964 PyObject * obj1 = 0 ;
50965 PyObject * obj2 = 0 ;
50966 PyObject * obj3 = 0 ;
50967 char * kwnames[] = {
50968 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50969 };
50970
50971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50973 if (!SWIG_IsOK(res1)) {
50974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50975 }
50976 arg1 = reinterpret_cast< wxSizer * >(argp1);
50977 arg2 = obj1;
50978 if (obj2) {
50979 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50980 if (!SWIG_IsOK(ecode3)) {
50981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50982 }
50983 arg3 = static_cast< bool >(val3);
50984 }
50985 if (obj3) {
50986 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50987 if (!SWIG_IsOK(ecode4)) {
50988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
50989 }
50990 arg4 = static_cast< bool >(val4);
50991 }
50992 {
50993 PyThreadState* __tstate = wxPyBeginAllowThreads();
50994 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
50995 wxPyEndAllowThreads(__tstate);
50996 if (PyErr_Occurred()) SWIG_fail;
50997 }
50998 {
50999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51000 }
51001 return resultobj;
51002 fail:
51003 return NULL;
51004 }
51005
51006
51007 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51008 PyObject *resultobj = 0;
51009 wxSizer *arg1 = (wxSizer *) 0 ;
51010 PyObject *arg2 = (PyObject *) 0 ;
51011 bool result;
51012 void *argp1 = 0 ;
51013 int res1 = 0 ;
51014 PyObject * obj0 = 0 ;
51015 PyObject * obj1 = 0 ;
51016 char * kwnames[] = {
51017 (char *) "self",(char *) "item", NULL
51018 };
51019
51020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51022 if (!SWIG_IsOK(res1)) {
51023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51024 }
51025 arg1 = reinterpret_cast< wxSizer * >(argp1);
51026 arg2 = obj1;
51027 {
51028 PyThreadState* __tstate = wxPyBeginAllowThreads();
51029 result = (bool)wxSizer_IsShown(arg1,arg2);
51030 wxPyEndAllowThreads(__tstate);
51031 if (PyErr_Occurred()) SWIG_fail;
51032 }
51033 {
51034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51035 }
51036 return resultobj;
51037 fail:
51038 return NULL;
51039 }
51040
51041
51042 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51043 PyObject *resultobj = 0;
51044 wxSizer *arg1 = (wxSizer *) 0 ;
51045 bool arg2 ;
51046 void *argp1 = 0 ;
51047 int res1 = 0 ;
51048 bool val2 ;
51049 int ecode2 = 0 ;
51050 PyObject * obj0 = 0 ;
51051 PyObject * obj1 = 0 ;
51052 char * kwnames[] = {
51053 (char *) "self",(char *) "show", NULL
51054 };
51055
51056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51058 if (!SWIG_IsOK(res1)) {
51059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51060 }
51061 arg1 = reinterpret_cast< wxSizer * >(argp1);
51062 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51063 if (!SWIG_IsOK(ecode2)) {
51064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51065 }
51066 arg2 = static_cast< bool >(val2);
51067 {
51068 PyThreadState* __tstate = wxPyBeginAllowThreads();
51069 (arg1)->ShowItems(arg2);
51070 wxPyEndAllowThreads(__tstate);
51071 if (PyErr_Occurred()) SWIG_fail;
51072 }
51073 resultobj = SWIG_Py_Void();
51074 return resultobj;
51075 fail:
51076 return NULL;
51077 }
51078
51079
51080 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51081 PyObject *obj;
51082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51083 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51084 return SWIG_Py_Void();
51085 }
51086
51087 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51088 PyObject *resultobj = 0;
51089 wxPySizer *result = 0 ;
51090
51091 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51092 {
51093 PyThreadState* __tstate = wxPyBeginAllowThreads();
51094 result = (wxPySizer *)new wxPySizer();
51095 wxPyEndAllowThreads(__tstate);
51096 if (PyErr_Occurred()) SWIG_fail;
51097 }
51098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51099 return resultobj;
51100 fail:
51101 return NULL;
51102 }
51103
51104
51105 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51106 PyObject *resultobj = 0;
51107 wxPySizer *arg1 = (wxPySizer *) 0 ;
51108 PyObject *arg2 = (PyObject *) 0 ;
51109 PyObject *arg3 = (PyObject *) 0 ;
51110 void *argp1 = 0 ;
51111 int res1 = 0 ;
51112 PyObject * obj0 = 0 ;
51113 PyObject * obj1 = 0 ;
51114 PyObject * obj2 = 0 ;
51115 char * kwnames[] = {
51116 (char *) "self",(char *) "self",(char *) "_class", NULL
51117 };
51118
51119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51121 if (!SWIG_IsOK(res1)) {
51122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51123 }
51124 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51125 arg2 = obj1;
51126 arg3 = obj2;
51127 {
51128 PyThreadState* __tstate = wxPyBeginAllowThreads();
51129 (arg1)->_setCallbackInfo(arg2,arg3);
51130 wxPyEndAllowThreads(__tstate);
51131 if (PyErr_Occurred()) SWIG_fail;
51132 }
51133 resultobj = SWIG_Py_Void();
51134 return resultobj;
51135 fail:
51136 return NULL;
51137 }
51138
51139
51140 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51141 PyObject *obj;
51142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51143 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51144 return SWIG_Py_Void();
51145 }
51146
51147 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51148 return SWIG_Python_InitShadowInstance(args);
51149 }
51150
51151 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51152 PyObject *resultobj = 0;
51153 int arg1 = (int) wxHORIZONTAL ;
51154 wxBoxSizer *result = 0 ;
51155 int val1 ;
51156 int ecode1 = 0 ;
51157 PyObject * obj0 = 0 ;
51158 char * kwnames[] = {
51159 (char *) "orient", NULL
51160 };
51161
51162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51163 if (obj0) {
51164 ecode1 = SWIG_AsVal_int(obj0, &val1);
51165 if (!SWIG_IsOK(ecode1)) {
51166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51167 }
51168 arg1 = static_cast< int >(val1);
51169 }
51170 {
51171 PyThreadState* __tstate = wxPyBeginAllowThreads();
51172 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51173 wxPyEndAllowThreads(__tstate);
51174 if (PyErr_Occurred()) SWIG_fail;
51175 }
51176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51177 return resultobj;
51178 fail:
51179 return NULL;
51180 }
51181
51182
51183 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51184 PyObject *resultobj = 0;
51185 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51186 int result;
51187 void *argp1 = 0 ;
51188 int res1 = 0 ;
51189 PyObject *swig_obj[1] ;
51190
51191 if (!args) SWIG_fail;
51192 swig_obj[0] = args;
51193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51194 if (!SWIG_IsOK(res1)) {
51195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51196 }
51197 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51198 {
51199 PyThreadState* __tstate = wxPyBeginAllowThreads();
51200 result = (int)(arg1)->GetOrientation();
51201 wxPyEndAllowThreads(__tstate);
51202 if (PyErr_Occurred()) SWIG_fail;
51203 }
51204 resultobj = SWIG_From_int(static_cast< int >(result));
51205 return resultobj;
51206 fail:
51207 return NULL;
51208 }
51209
51210
51211 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51212 PyObject *resultobj = 0;
51213 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51214 int arg2 ;
51215 void *argp1 = 0 ;
51216 int res1 = 0 ;
51217 int val2 ;
51218 int ecode2 = 0 ;
51219 PyObject * obj0 = 0 ;
51220 PyObject * obj1 = 0 ;
51221 char * kwnames[] = {
51222 (char *) "self",(char *) "orient", NULL
51223 };
51224
51225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51227 if (!SWIG_IsOK(res1)) {
51228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51229 }
51230 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51231 ecode2 = SWIG_AsVal_int(obj1, &val2);
51232 if (!SWIG_IsOK(ecode2)) {
51233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51234 }
51235 arg2 = static_cast< int >(val2);
51236 {
51237 PyThreadState* __tstate = wxPyBeginAllowThreads();
51238 (arg1)->SetOrientation(arg2);
51239 wxPyEndAllowThreads(__tstate);
51240 if (PyErr_Occurred()) SWIG_fail;
51241 }
51242 resultobj = SWIG_Py_Void();
51243 return resultobj;
51244 fail:
51245 return NULL;
51246 }
51247
51248
51249 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51250 PyObject *obj;
51251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51252 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51253 return SWIG_Py_Void();
51254 }
51255
51256 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51257 return SWIG_Python_InitShadowInstance(args);
51258 }
51259
51260 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51261 PyObject *resultobj = 0;
51262 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51263 int arg2 = (int) wxHORIZONTAL ;
51264 wxStaticBoxSizer *result = 0 ;
51265 void *argp1 = 0 ;
51266 int res1 = 0 ;
51267 int val2 ;
51268 int ecode2 = 0 ;
51269 PyObject * obj0 = 0 ;
51270 PyObject * obj1 = 0 ;
51271 char * kwnames[] = {
51272 (char *) "box",(char *) "orient", NULL
51273 };
51274
51275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51277 if (!SWIG_IsOK(res1)) {
51278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51279 }
51280 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51281 if (obj1) {
51282 ecode2 = SWIG_AsVal_int(obj1, &val2);
51283 if (!SWIG_IsOK(ecode2)) {
51284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51285 }
51286 arg2 = static_cast< int >(val2);
51287 }
51288 {
51289 PyThreadState* __tstate = wxPyBeginAllowThreads();
51290 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51291 wxPyEndAllowThreads(__tstate);
51292 if (PyErr_Occurred()) SWIG_fail;
51293 }
51294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51295 return resultobj;
51296 fail:
51297 return NULL;
51298 }
51299
51300
51301 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51302 PyObject *resultobj = 0;
51303 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51304 wxStaticBox *result = 0 ;
51305 void *argp1 = 0 ;
51306 int res1 = 0 ;
51307 PyObject *swig_obj[1] ;
51308
51309 if (!args) SWIG_fail;
51310 swig_obj[0] = args;
51311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51312 if (!SWIG_IsOK(res1)) {
51313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51314 }
51315 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51316 {
51317 PyThreadState* __tstate = wxPyBeginAllowThreads();
51318 result = (wxStaticBox *)(arg1)->GetStaticBox();
51319 wxPyEndAllowThreads(__tstate);
51320 if (PyErr_Occurred()) SWIG_fail;
51321 }
51322 {
51323 resultobj = wxPyMake_wxObject(result, (bool)0);
51324 }
51325 return resultobj;
51326 fail:
51327 return NULL;
51328 }
51329
51330
51331 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51332 PyObject *obj;
51333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51334 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51335 return SWIG_Py_Void();
51336 }
51337
51338 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51339 return SWIG_Python_InitShadowInstance(args);
51340 }
51341
51342 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51343 PyObject *resultobj = 0;
51344 int arg1 = (int) 1 ;
51345 int arg2 = (int) 0 ;
51346 int arg3 = (int) 0 ;
51347 int arg4 = (int) 0 ;
51348 wxGridSizer *result = 0 ;
51349 int val1 ;
51350 int ecode1 = 0 ;
51351 int val2 ;
51352 int ecode2 = 0 ;
51353 int val3 ;
51354 int ecode3 = 0 ;
51355 int val4 ;
51356 int ecode4 = 0 ;
51357 PyObject * obj0 = 0 ;
51358 PyObject * obj1 = 0 ;
51359 PyObject * obj2 = 0 ;
51360 PyObject * obj3 = 0 ;
51361 char * kwnames[] = {
51362 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51363 };
51364
51365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51366 if (obj0) {
51367 ecode1 = SWIG_AsVal_int(obj0, &val1);
51368 if (!SWIG_IsOK(ecode1)) {
51369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51370 }
51371 arg1 = static_cast< int >(val1);
51372 }
51373 if (obj1) {
51374 ecode2 = SWIG_AsVal_int(obj1, &val2);
51375 if (!SWIG_IsOK(ecode2)) {
51376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51377 }
51378 arg2 = static_cast< int >(val2);
51379 }
51380 if (obj2) {
51381 ecode3 = SWIG_AsVal_int(obj2, &val3);
51382 if (!SWIG_IsOK(ecode3)) {
51383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51384 }
51385 arg3 = static_cast< int >(val3);
51386 }
51387 if (obj3) {
51388 ecode4 = SWIG_AsVal_int(obj3, &val4);
51389 if (!SWIG_IsOK(ecode4)) {
51390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51391 }
51392 arg4 = static_cast< int >(val4);
51393 }
51394 {
51395 PyThreadState* __tstate = wxPyBeginAllowThreads();
51396 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51397 wxPyEndAllowThreads(__tstate);
51398 if (PyErr_Occurred()) SWIG_fail;
51399 }
51400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51401 return resultobj;
51402 fail:
51403 return NULL;
51404 }
51405
51406
51407 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51408 PyObject *resultobj = 0;
51409 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51410 int arg2 ;
51411 void *argp1 = 0 ;
51412 int res1 = 0 ;
51413 int val2 ;
51414 int ecode2 = 0 ;
51415 PyObject * obj0 = 0 ;
51416 PyObject * obj1 = 0 ;
51417 char * kwnames[] = {
51418 (char *) "self",(char *) "cols", NULL
51419 };
51420
51421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51423 if (!SWIG_IsOK(res1)) {
51424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51425 }
51426 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51427 ecode2 = SWIG_AsVal_int(obj1, &val2);
51428 if (!SWIG_IsOK(ecode2)) {
51429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51430 }
51431 arg2 = static_cast< int >(val2);
51432 {
51433 PyThreadState* __tstate = wxPyBeginAllowThreads();
51434 (arg1)->SetCols(arg2);
51435 wxPyEndAllowThreads(__tstate);
51436 if (PyErr_Occurred()) SWIG_fail;
51437 }
51438 resultobj = SWIG_Py_Void();
51439 return resultobj;
51440 fail:
51441 return NULL;
51442 }
51443
51444
51445 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51446 PyObject *resultobj = 0;
51447 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51448 int arg2 ;
51449 void *argp1 = 0 ;
51450 int res1 = 0 ;
51451 int val2 ;
51452 int ecode2 = 0 ;
51453 PyObject * obj0 = 0 ;
51454 PyObject * obj1 = 0 ;
51455 char * kwnames[] = {
51456 (char *) "self",(char *) "rows", NULL
51457 };
51458
51459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51461 if (!SWIG_IsOK(res1)) {
51462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51463 }
51464 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51465 ecode2 = SWIG_AsVal_int(obj1, &val2);
51466 if (!SWIG_IsOK(ecode2)) {
51467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51468 }
51469 arg2 = static_cast< int >(val2);
51470 {
51471 PyThreadState* __tstate = wxPyBeginAllowThreads();
51472 (arg1)->SetRows(arg2);
51473 wxPyEndAllowThreads(__tstate);
51474 if (PyErr_Occurred()) SWIG_fail;
51475 }
51476 resultobj = SWIG_Py_Void();
51477 return resultobj;
51478 fail:
51479 return NULL;
51480 }
51481
51482
51483 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51484 PyObject *resultobj = 0;
51485 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51486 int arg2 ;
51487 void *argp1 = 0 ;
51488 int res1 = 0 ;
51489 int val2 ;
51490 int ecode2 = 0 ;
51491 PyObject * obj0 = 0 ;
51492 PyObject * obj1 = 0 ;
51493 char * kwnames[] = {
51494 (char *) "self",(char *) "gap", NULL
51495 };
51496
51497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51499 if (!SWIG_IsOK(res1)) {
51500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51501 }
51502 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51503 ecode2 = SWIG_AsVal_int(obj1, &val2);
51504 if (!SWIG_IsOK(ecode2)) {
51505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51506 }
51507 arg2 = static_cast< int >(val2);
51508 {
51509 PyThreadState* __tstate = wxPyBeginAllowThreads();
51510 (arg1)->SetVGap(arg2);
51511 wxPyEndAllowThreads(__tstate);
51512 if (PyErr_Occurred()) SWIG_fail;
51513 }
51514 resultobj = SWIG_Py_Void();
51515 return resultobj;
51516 fail:
51517 return NULL;
51518 }
51519
51520
51521 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51522 PyObject *resultobj = 0;
51523 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51524 int arg2 ;
51525 void *argp1 = 0 ;
51526 int res1 = 0 ;
51527 int val2 ;
51528 int ecode2 = 0 ;
51529 PyObject * obj0 = 0 ;
51530 PyObject * obj1 = 0 ;
51531 char * kwnames[] = {
51532 (char *) "self",(char *) "gap", NULL
51533 };
51534
51535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51537 if (!SWIG_IsOK(res1)) {
51538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51539 }
51540 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51541 ecode2 = SWIG_AsVal_int(obj1, &val2);
51542 if (!SWIG_IsOK(ecode2)) {
51543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51544 }
51545 arg2 = static_cast< int >(val2);
51546 {
51547 PyThreadState* __tstate = wxPyBeginAllowThreads();
51548 (arg1)->SetHGap(arg2);
51549 wxPyEndAllowThreads(__tstate);
51550 if (PyErr_Occurred()) SWIG_fail;
51551 }
51552 resultobj = SWIG_Py_Void();
51553 return resultobj;
51554 fail:
51555 return NULL;
51556 }
51557
51558
51559 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51560 PyObject *resultobj = 0;
51561 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51562 int result;
51563 void *argp1 = 0 ;
51564 int res1 = 0 ;
51565 PyObject *swig_obj[1] ;
51566
51567 if (!args) SWIG_fail;
51568 swig_obj[0] = args;
51569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51570 if (!SWIG_IsOK(res1)) {
51571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51572 }
51573 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51574 {
51575 PyThreadState* __tstate = wxPyBeginAllowThreads();
51576 result = (int)(arg1)->GetCols();
51577 wxPyEndAllowThreads(__tstate);
51578 if (PyErr_Occurred()) SWIG_fail;
51579 }
51580 resultobj = SWIG_From_int(static_cast< int >(result));
51581 return resultobj;
51582 fail:
51583 return NULL;
51584 }
51585
51586
51587 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51588 PyObject *resultobj = 0;
51589 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51590 int result;
51591 void *argp1 = 0 ;
51592 int res1 = 0 ;
51593 PyObject *swig_obj[1] ;
51594
51595 if (!args) SWIG_fail;
51596 swig_obj[0] = args;
51597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51598 if (!SWIG_IsOK(res1)) {
51599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51600 }
51601 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51602 {
51603 PyThreadState* __tstate = wxPyBeginAllowThreads();
51604 result = (int)(arg1)->GetRows();
51605 wxPyEndAllowThreads(__tstate);
51606 if (PyErr_Occurred()) SWIG_fail;
51607 }
51608 resultobj = SWIG_From_int(static_cast< int >(result));
51609 return resultobj;
51610 fail:
51611 return NULL;
51612 }
51613
51614
51615 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51616 PyObject *resultobj = 0;
51617 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51618 int result;
51619 void *argp1 = 0 ;
51620 int res1 = 0 ;
51621 PyObject *swig_obj[1] ;
51622
51623 if (!args) SWIG_fail;
51624 swig_obj[0] = args;
51625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51626 if (!SWIG_IsOK(res1)) {
51627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51628 }
51629 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51630 {
51631 PyThreadState* __tstate = wxPyBeginAllowThreads();
51632 result = (int)(arg1)->GetVGap();
51633 wxPyEndAllowThreads(__tstate);
51634 if (PyErr_Occurred()) SWIG_fail;
51635 }
51636 resultobj = SWIG_From_int(static_cast< int >(result));
51637 return resultobj;
51638 fail:
51639 return NULL;
51640 }
51641
51642
51643 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51644 PyObject *resultobj = 0;
51645 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51646 int result;
51647 void *argp1 = 0 ;
51648 int res1 = 0 ;
51649 PyObject *swig_obj[1] ;
51650
51651 if (!args) SWIG_fail;
51652 swig_obj[0] = args;
51653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51654 if (!SWIG_IsOK(res1)) {
51655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51656 }
51657 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51658 {
51659 PyThreadState* __tstate = wxPyBeginAllowThreads();
51660 result = (int)(arg1)->GetHGap();
51661 wxPyEndAllowThreads(__tstate);
51662 if (PyErr_Occurred()) SWIG_fail;
51663 }
51664 resultobj = SWIG_From_int(static_cast< int >(result));
51665 return resultobj;
51666 fail:
51667 return NULL;
51668 }
51669
51670
51671 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51672 PyObject *obj;
51673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51674 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51675 return SWIG_Py_Void();
51676 }
51677
51678 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51679 return SWIG_Python_InitShadowInstance(args);
51680 }
51681
51682 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51683 PyObject *resultobj = 0;
51684 int arg1 = (int) 1 ;
51685 int arg2 = (int) 0 ;
51686 int arg3 = (int) 0 ;
51687 int arg4 = (int) 0 ;
51688 wxFlexGridSizer *result = 0 ;
51689 int val1 ;
51690 int ecode1 = 0 ;
51691 int val2 ;
51692 int ecode2 = 0 ;
51693 int val3 ;
51694 int ecode3 = 0 ;
51695 int val4 ;
51696 int ecode4 = 0 ;
51697 PyObject * obj0 = 0 ;
51698 PyObject * obj1 = 0 ;
51699 PyObject * obj2 = 0 ;
51700 PyObject * obj3 = 0 ;
51701 char * kwnames[] = {
51702 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51703 };
51704
51705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51706 if (obj0) {
51707 ecode1 = SWIG_AsVal_int(obj0, &val1);
51708 if (!SWIG_IsOK(ecode1)) {
51709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51710 }
51711 arg1 = static_cast< int >(val1);
51712 }
51713 if (obj1) {
51714 ecode2 = SWIG_AsVal_int(obj1, &val2);
51715 if (!SWIG_IsOK(ecode2)) {
51716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51717 }
51718 arg2 = static_cast< int >(val2);
51719 }
51720 if (obj2) {
51721 ecode3 = SWIG_AsVal_int(obj2, &val3);
51722 if (!SWIG_IsOK(ecode3)) {
51723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51724 }
51725 arg3 = static_cast< int >(val3);
51726 }
51727 if (obj3) {
51728 ecode4 = SWIG_AsVal_int(obj3, &val4);
51729 if (!SWIG_IsOK(ecode4)) {
51730 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51731 }
51732 arg4 = static_cast< int >(val4);
51733 }
51734 {
51735 PyThreadState* __tstate = wxPyBeginAllowThreads();
51736 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51737 wxPyEndAllowThreads(__tstate);
51738 if (PyErr_Occurred()) SWIG_fail;
51739 }
51740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51741 return resultobj;
51742 fail:
51743 return NULL;
51744 }
51745
51746
51747 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51748 PyObject *resultobj = 0;
51749 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51750 size_t arg2 ;
51751 int arg3 = (int) 0 ;
51752 void *argp1 = 0 ;
51753 int res1 = 0 ;
51754 size_t val2 ;
51755 int ecode2 = 0 ;
51756 int val3 ;
51757 int ecode3 = 0 ;
51758 PyObject * obj0 = 0 ;
51759 PyObject * obj1 = 0 ;
51760 PyObject * obj2 = 0 ;
51761 char * kwnames[] = {
51762 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51763 };
51764
51765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51767 if (!SWIG_IsOK(res1)) {
51768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51769 }
51770 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51771 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51772 if (!SWIG_IsOK(ecode2)) {
51773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51774 }
51775 arg2 = static_cast< size_t >(val2);
51776 if (obj2) {
51777 ecode3 = SWIG_AsVal_int(obj2, &val3);
51778 if (!SWIG_IsOK(ecode3)) {
51779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51780 }
51781 arg3 = static_cast< int >(val3);
51782 }
51783 {
51784 PyThreadState* __tstate = wxPyBeginAllowThreads();
51785 (arg1)->AddGrowableRow(arg2,arg3);
51786 wxPyEndAllowThreads(__tstate);
51787 if (PyErr_Occurred()) SWIG_fail;
51788 }
51789 resultobj = SWIG_Py_Void();
51790 return resultobj;
51791 fail:
51792 return NULL;
51793 }
51794
51795
51796 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51797 PyObject *resultobj = 0;
51798 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51799 size_t arg2 ;
51800 void *argp1 = 0 ;
51801 int res1 = 0 ;
51802 size_t val2 ;
51803 int ecode2 = 0 ;
51804 PyObject * obj0 = 0 ;
51805 PyObject * obj1 = 0 ;
51806 char * kwnames[] = {
51807 (char *) "self",(char *) "idx", NULL
51808 };
51809
51810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51814 }
51815 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51816 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51817 if (!SWIG_IsOK(ecode2)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51819 }
51820 arg2 = static_cast< size_t >(val2);
51821 {
51822 PyThreadState* __tstate = wxPyBeginAllowThreads();
51823 (arg1)->RemoveGrowableRow(arg2);
51824 wxPyEndAllowThreads(__tstate);
51825 if (PyErr_Occurred()) SWIG_fail;
51826 }
51827 resultobj = SWIG_Py_Void();
51828 return resultobj;
51829 fail:
51830 return NULL;
51831 }
51832
51833
51834 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51835 PyObject *resultobj = 0;
51836 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51837 size_t arg2 ;
51838 int arg3 = (int) 0 ;
51839 void *argp1 = 0 ;
51840 int res1 = 0 ;
51841 size_t val2 ;
51842 int ecode2 = 0 ;
51843 int val3 ;
51844 int ecode3 = 0 ;
51845 PyObject * obj0 = 0 ;
51846 PyObject * obj1 = 0 ;
51847 PyObject * obj2 = 0 ;
51848 char * kwnames[] = {
51849 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51850 };
51851
51852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51854 if (!SWIG_IsOK(res1)) {
51855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51856 }
51857 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51858 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51859 if (!SWIG_IsOK(ecode2)) {
51860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51861 }
51862 arg2 = static_cast< size_t >(val2);
51863 if (obj2) {
51864 ecode3 = SWIG_AsVal_int(obj2, &val3);
51865 if (!SWIG_IsOK(ecode3)) {
51866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51867 }
51868 arg3 = static_cast< int >(val3);
51869 }
51870 {
51871 PyThreadState* __tstate = wxPyBeginAllowThreads();
51872 (arg1)->AddGrowableCol(arg2,arg3);
51873 wxPyEndAllowThreads(__tstate);
51874 if (PyErr_Occurred()) SWIG_fail;
51875 }
51876 resultobj = SWIG_Py_Void();
51877 return resultobj;
51878 fail:
51879 return NULL;
51880 }
51881
51882
51883 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51884 PyObject *resultobj = 0;
51885 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51886 size_t arg2 ;
51887 void *argp1 = 0 ;
51888 int res1 = 0 ;
51889 size_t val2 ;
51890 int ecode2 = 0 ;
51891 PyObject * obj0 = 0 ;
51892 PyObject * obj1 = 0 ;
51893 char * kwnames[] = {
51894 (char *) "self",(char *) "idx", NULL
51895 };
51896
51897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51899 if (!SWIG_IsOK(res1)) {
51900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51901 }
51902 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51903 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51904 if (!SWIG_IsOK(ecode2)) {
51905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51906 }
51907 arg2 = static_cast< size_t >(val2);
51908 {
51909 PyThreadState* __tstate = wxPyBeginAllowThreads();
51910 (arg1)->RemoveGrowableCol(arg2);
51911 wxPyEndAllowThreads(__tstate);
51912 if (PyErr_Occurred()) SWIG_fail;
51913 }
51914 resultobj = SWIG_Py_Void();
51915 return resultobj;
51916 fail:
51917 return NULL;
51918 }
51919
51920
51921 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51922 PyObject *resultobj = 0;
51923 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51924 int arg2 ;
51925 void *argp1 = 0 ;
51926 int res1 = 0 ;
51927 int val2 ;
51928 int ecode2 = 0 ;
51929 PyObject * obj0 = 0 ;
51930 PyObject * obj1 = 0 ;
51931 char * kwnames[] = {
51932 (char *) "self",(char *) "direction", NULL
51933 };
51934
51935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51937 if (!SWIG_IsOK(res1)) {
51938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51939 }
51940 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51941 ecode2 = SWIG_AsVal_int(obj1, &val2);
51942 if (!SWIG_IsOK(ecode2)) {
51943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51944 }
51945 arg2 = static_cast< int >(val2);
51946 {
51947 PyThreadState* __tstate = wxPyBeginAllowThreads();
51948 (arg1)->SetFlexibleDirection(arg2);
51949 wxPyEndAllowThreads(__tstate);
51950 if (PyErr_Occurred()) SWIG_fail;
51951 }
51952 resultobj = SWIG_Py_Void();
51953 return resultobj;
51954 fail:
51955 return NULL;
51956 }
51957
51958
51959 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51960 PyObject *resultobj = 0;
51961 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51962 int result;
51963 void *argp1 = 0 ;
51964 int res1 = 0 ;
51965 PyObject *swig_obj[1] ;
51966
51967 if (!args) SWIG_fail;
51968 swig_obj[0] = args;
51969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51970 if (!SWIG_IsOK(res1)) {
51971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51972 }
51973 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51974 {
51975 PyThreadState* __tstate = wxPyBeginAllowThreads();
51976 result = (int)(arg1)->GetFlexibleDirection();
51977 wxPyEndAllowThreads(__tstate);
51978 if (PyErr_Occurred()) SWIG_fail;
51979 }
51980 resultobj = SWIG_From_int(static_cast< int >(result));
51981 return resultobj;
51982 fail:
51983 return NULL;
51984 }
51985
51986
51987 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51988 PyObject *resultobj = 0;
51989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51990 wxFlexSizerGrowMode arg2 ;
51991 void *argp1 = 0 ;
51992 int res1 = 0 ;
51993 int val2 ;
51994 int ecode2 = 0 ;
51995 PyObject * obj0 = 0 ;
51996 PyObject * obj1 = 0 ;
51997 char * kwnames[] = {
51998 (char *) "self",(char *) "mode", NULL
51999 };
52000
52001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52003 if (!SWIG_IsOK(res1)) {
52004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52005 }
52006 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52007 ecode2 = SWIG_AsVal_int(obj1, &val2);
52008 if (!SWIG_IsOK(ecode2)) {
52009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52010 }
52011 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52012 {
52013 PyThreadState* __tstate = wxPyBeginAllowThreads();
52014 (arg1)->SetNonFlexibleGrowMode(arg2);
52015 wxPyEndAllowThreads(__tstate);
52016 if (PyErr_Occurred()) SWIG_fail;
52017 }
52018 resultobj = SWIG_Py_Void();
52019 return resultobj;
52020 fail:
52021 return NULL;
52022 }
52023
52024
52025 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52026 PyObject *resultobj = 0;
52027 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52028 wxFlexSizerGrowMode result;
52029 void *argp1 = 0 ;
52030 int res1 = 0 ;
52031 PyObject *swig_obj[1] ;
52032
52033 if (!args) SWIG_fail;
52034 swig_obj[0] = args;
52035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52036 if (!SWIG_IsOK(res1)) {
52037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52038 }
52039 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52040 {
52041 PyThreadState* __tstate = wxPyBeginAllowThreads();
52042 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52043 wxPyEndAllowThreads(__tstate);
52044 if (PyErr_Occurred()) SWIG_fail;
52045 }
52046 resultobj = SWIG_From_int(static_cast< int >(result));
52047 return resultobj;
52048 fail:
52049 return NULL;
52050 }
52051
52052
52053 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52054 PyObject *resultobj = 0;
52055 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52056 wxArrayInt *result = 0 ;
52057 void *argp1 = 0 ;
52058 int res1 = 0 ;
52059 PyObject *swig_obj[1] ;
52060
52061 if (!args) SWIG_fail;
52062 swig_obj[0] = args;
52063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52064 if (!SWIG_IsOK(res1)) {
52065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52066 }
52067 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52068 {
52069 PyThreadState* __tstate = wxPyBeginAllowThreads();
52070 {
52071 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52072 result = (wxArrayInt *) &_result_ref;
52073 }
52074 wxPyEndAllowThreads(__tstate);
52075 if (PyErr_Occurred()) SWIG_fail;
52076 }
52077 {
52078 resultobj = wxArrayInt2PyList_helper(*result);
52079 }
52080 return resultobj;
52081 fail:
52082 return NULL;
52083 }
52084
52085
52086 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52087 PyObject *resultobj = 0;
52088 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52089 wxArrayInt *result = 0 ;
52090 void *argp1 = 0 ;
52091 int res1 = 0 ;
52092 PyObject *swig_obj[1] ;
52093
52094 if (!args) SWIG_fail;
52095 swig_obj[0] = args;
52096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52097 if (!SWIG_IsOK(res1)) {
52098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52099 }
52100 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52101 {
52102 PyThreadState* __tstate = wxPyBeginAllowThreads();
52103 {
52104 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52105 result = (wxArrayInt *) &_result_ref;
52106 }
52107 wxPyEndAllowThreads(__tstate);
52108 if (PyErr_Occurred()) SWIG_fail;
52109 }
52110 {
52111 resultobj = wxArrayInt2PyList_helper(*result);
52112 }
52113 return resultobj;
52114 fail:
52115 return NULL;
52116 }
52117
52118
52119 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52120 PyObject *obj;
52121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52122 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52123 return SWIG_Py_Void();
52124 }
52125
52126 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52127 return SWIG_Python_InitShadowInstance(args);
52128 }
52129
52130 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52131 PyObject *resultobj = 0;
52132 wxStdDialogButtonSizer *result = 0 ;
52133
52134 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52135 {
52136 PyThreadState* __tstate = wxPyBeginAllowThreads();
52137 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52138 wxPyEndAllowThreads(__tstate);
52139 if (PyErr_Occurred()) SWIG_fail;
52140 }
52141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52142 return resultobj;
52143 fail:
52144 return NULL;
52145 }
52146
52147
52148 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52149 PyObject *resultobj = 0;
52150 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52151 wxButton *arg2 = (wxButton *) 0 ;
52152 void *argp1 = 0 ;
52153 int res1 = 0 ;
52154 void *argp2 = 0 ;
52155 int res2 = 0 ;
52156 PyObject * obj0 = 0 ;
52157 PyObject * obj1 = 0 ;
52158 char * kwnames[] = {
52159 (char *) "self",(char *) "button", NULL
52160 };
52161
52162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52164 if (!SWIG_IsOK(res1)) {
52165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52166 }
52167 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52169 if (!SWIG_IsOK(res2)) {
52170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52171 }
52172 arg2 = reinterpret_cast< wxButton * >(argp2);
52173 {
52174 PyThreadState* __tstate = wxPyBeginAllowThreads();
52175 (arg1)->AddButton(arg2);
52176 wxPyEndAllowThreads(__tstate);
52177 if (PyErr_Occurred()) SWIG_fail;
52178 }
52179 resultobj = SWIG_Py_Void();
52180 return resultobj;
52181 fail:
52182 return NULL;
52183 }
52184
52185
52186 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52187 PyObject *resultobj = 0;
52188 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52189 void *argp1 = 0 ;
52190 int res1 = 0 ;
52191 PyObject *swig_obj[1] ;
52192
52193 if (!args) SWIG_fail;
52194 swig_obj[0] = args;
52195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52196 if (!SWIG_IsOK(res1)) {
52197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52198 }
52199 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52200 {
52201 PyThreadState* __tstate = wxPyBeginAllowThreads();
52202 (arg1)->Realize();
52203 wxPyEndAllowThreads(__tstate);
52204 if (PyErr_Occurred()) SWIG_fail;
52205 }
52206 resultobj = SWIG_Py_Void();
52207 return resultobj;
52208 fail:
52209 return NULL;
52210 }
52211
52212
52213 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52214 PyObject *resultobj = 0;
52215 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52216 wxButton *arg2 = (wxButton *) 0 ;
52217 void *argp1 = 0 ;
52218 int res1 = 0 ;
52219 void *argp2 = 0 ;
52220 int res2 = 0 ;
52221 PyObject * obj0 = 0 ;
52222 PyObject * obj1 = 0 ;
52223 char * kwnames[] = {
52224 (char *) "self",(char *) "button", NULL
52225 };
52226
52227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52229 if (!SWIG_IsOK(res1)) {
52230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52231 }
52232 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52234 if (!SWIG_IsOK(res2)) {
52235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52236 }
52237 arg2 = reinterpret_cast< wxButton * >(argp2);
52238 {
52239 PyThreadState* __tstate = wxPyBeginAllowThreads();
52240 (arg1)->SetAffirmativeButton(arg2);
52241 wxPyEndAllowThreads(__tstate);
52242 if (PyErr_Occurred()) SWIG_fail;
52243 }
52244 resultobj = SWIG_Py_Void();
52245 return resultobj;
52246 fail:
52247 return NULL;
52248 }
52249
52250
52251 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52252 PyObject *resultobj = 0;
52253 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52254 wxButton *arg2 = (wxButton *) 0 ;
52255 void *argp1 = 0 ;
52256 int res1 = 0 ;
52257 void *argp2 = 0 ;
52258 int res2 = 0 ;
52259 PyObject * obj0 = 0 ;
52260 PyObject * obj1 = 0 ;
52261 char * kwnames[] = {
52262 (char *) "self",(char *) "button", NULL
52263 };
52264
52265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52267 if (!SWIG_IsOK(res1)) {
52268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52269 }
52270 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52272 if (!SWIG_IsOK(res2)) {
52273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52274 }
52275 arg2 = reinterpret_cast< wxButton * >(argp2);
52276 {
52277 PyThreadState* __tstate = wxPyBeginAllowThreads();
52278 (arg1)->SetNegativeButton(arg2);
52279 wxPyEndAllowThreads(__tstate);
52280 if (PyErr_Occurred()) SWIG_fail;
52281 }
52282 resultobj = SWIG_Py_Void();
52283 return resultobj;
52284 fail:
52285 return NULL;
52286 }
52287
52288
52289 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52290 PyObject *resultobj = 0;
52291 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52292 wxButton *arg2 = (wxButton *) 0 ;
52293 void *argp1 = 0 ;
52294 int res1 = 0 ;
52295 void *argp2 = 0 ;
52296 int res2 = 0 ;
52297 PyObject * obj0 = 0 ;
52298 PyObject * obj1 = 0 ;
52299 char * kwnames[] = {
52300 (char *) "self",(char *) "button", NULL
52301 };
52302
52303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52305 if (!SWIG_IsOK(res1)) {
52306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52307 }
52308 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52310 if (!SWIG_IsOK(res2)) {
52311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52312 }
52313 arg2 = reinterpret_cast< wxButton * >(argp2);
52314 {
52315 PyThreadState* __tstate = wxPyBeginAllowThreads();
52316 (arg1)->SetCancelButton(arg2);
52317 wxPyEndAllowThreads(__tstate);
52318 if (PyErr_Occurred()) SWIG_fail;
52319 }
52320 resultobj = SWIG_Py_Void();
52321 return resultobj;
52322 fail:
52323 return NULL;
52324 }
52325
52326
52327 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52328 PyObject *resultobj = 0;
52329 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52330 wxButton *result = 0 ;
52331 void *argp1 = 0 ;
52332 int res1 = 0 ;
52333 PyObject *swig_obj[1] ;
52334
52335 if (!args) SWIG_fail;
52336 swig_obj[0] = args;
52337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52338 if (!SWIG_IsOK(res1)) {
52339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52340 }
52341 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52342 {
52343 PyThreadState* __tstate = wxPyBeginAllowThreads();
52344 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52345 wxPyEndAllowThreads(__tstate);
52346 if (PyErr_Occurred()) SWIG_fail;
52347 }
52348 {
52349 resultobj = wxPyMake_wxObject(result, (bool)0);
52350 }
52351 return resultobj;
52352 fail:
52353 return NULL;
52354 }
52355
52356
52357 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52358 PyObject *resultobj = 0;
52359 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52360 wxButton *result = 0 ;
52361 void *argp1 = 0 ;
52362 int res1 = 0 ;
52363 PyObject *swig_obj[1] ;
52364
52365 if (!args) SWIG_fail;
52366 swig_obj[0] = args;
52367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52368 if (!SWIG_IsOK(res1)) {
52369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52370 }
52371 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52372 {
52373 PyThreadState* __tstate = wxPyBeginAllowThreads();
52374 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52375 wxPyEndAllowThreads(__tstate);
52376 if (PyErr_Occurred()) SWIG_fail;
52377 }
52378 {
52379 resultobj = wxPyMake_wxObject(result, (bool)0);
52380 }
52381 return resultobj;
52382 fail:
52383 return NULL;
52384 }
52385
52386
52387 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52388 PyObject *resultobj = 0;
52389 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52390 wxButton *result = 0 ;
52391 void *argp1 = 0 ;
52392 int res1 = 0 ;
52393 PyObject *swig_obj[1] ;
52394
52395 if (!args) SWIG_fail;
52396 swig_obj[0] = args;
52397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52398 if (!SWIG_IsOK(res1)) {
52399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52400 }
52401 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52402 {
52403 PyThreadState* __tstate = wxPyBeginAllowThreads();
52404 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52405 wxPyEndAllowThreads(__tstate);
52406 if (PyErr_Occurred()) SWIG_fail;
52407 }
52408 {
52409 resultobj = wxPyMake_wxObject(result, (bool)0);
52410 }
52411 return resultobj;
52412 fail:
52413 return NULL;
52414 }
52415
52416
52417 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52418 PyObject *resultobj = 0;
52419 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52420 wxButton *result = 0 ;
52421 void *argp1 = 0 ;
52422 int res1 = 0 ;
52423 PyObject *swig_obj[1] ;
52424
52425 if (!args) SWIG_fail;
52426 swig_obj[0] = args;
52427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52428 if (!SWIG_IsOK(res1)) {
52429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52430 }
52431 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52432 {
52433 PyThreadState* __tstate = wxPyBeginAllowThreads();
52434 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52435 wxPyEndAllowThreads(__tstate);
52436 if (PyErr_Occurred()) SWIG_fail;
52437 }
52438 {
52439 resultobj = wxPyMake_wxObject(result, (bool)0);
52440 }
52441 return resultobj;
52442 fail:
52443 return NULL;
52444 }
52445
52446
52447 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52448 PyObject *resultobj = 0;
52449 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52450 wxButton *result = 0 ;
52451 void *argp1 = 0 ;
52452 int res1 = 0 ;
52453 PyObject *swig_obj[1] ;
52454
52455 if (!args) SWIG_fail;
52456 swig_obj[0] = args;
52457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52458 if (!SWIG_IsOK(res1)) {
52459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52460 }
52461 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52462 {
52463 PyThreadState* __tstate = wxPyBeginAllowThreads();
52464 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52465 wxPyEndAllowThreads(__tstate);
52466 if (PyErr_Occurred()) SWIG_fail;
52467 }
52468 {
52469 resultobj = wxPyMake_wxObject(result, (bool)0);
52470 }
52471 return resultobj;
52472 fail:
52473 return NULL;
52474 }
52475
52476
52477 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52478 PyObject *obj;
52479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52480 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52481 return SWIG_Py_Void();
52482 }
52483
52484 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52485 return SWIG_Python_InitShadowInstance(args);
52486 }
52487
52488 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52489 PyObject *resultobj = 0;
52490 int arg1 = (int) 0 ;
52491 int arg2 = (int) 0 ;
52492 wxGBPosition *result = 0 ;
52493 int val1 ;
52494 int ecode1 = 0 ;
52495 int val2 ;
52496 int ecode2 = 0 ;
52497 PyObject * obj0 = 0 ;
52498 PyObject * obj1 = 0 ;
52499 char * kwnames[] = {
52500 (char *) "row",(char *) "col", NULL
52501 };
52502
52503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52504 if (obj0) {
52505 ecode1 = SWIG_AsVal_int(obj0, &val1);
52506 if (!SWIG_IsOK(ecode1)) {
52507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52508 }
52509 arg1 = static_cast< int >(val1);
52510 }
52511 if (obj1) {
52512 ecode2 = SWIG_AsVal_int(obj1, &val2);
52513 if (!SWIG_IsOK(ecode2)) {
52514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52515 }
52516 arg2 = static_cast< int >(val2);
52517 }
52518 {
52519 PyThreadState* __tstate = wxPyBeginAllowThreads();
52520 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52521 wxPyEndAllowThreads(__tstate);
52522 if (PyErr_Occurred()) SWIG_fail;
52523 }
52524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52525 return resultobj;
52526 fail:
52527 return NULL;
52528 }
52529
52530
52531 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52532 PyObject *resultobj = 0;
52533 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52534 void *argp1 = 0 ;
52535 int res1 = 0 ;
52536 PyObject *swig_obj[1] ;
52537
52538 if (!args) SWIG_fail;
52539 swig_obj[0] = args;
52540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52541 if (!SWIG_IsOK(res1)) {
52542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52543 }
52544 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52545 {
52546 PyThreadState* __tstate = wxPyBeginAllowThreads();
52547 delete arg1;
52548
52549 wxPyEndAllowThreads(__tstate);
52550 if (PyErr_Occurred()) SWIG_fail;
52551 }
52552 resultobj = SWIG_Py_Void();
52553 return resultobj;
52554 fail:
52555 return NULL;
52556 }
52557
52558
52559 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52560 PyObject *resultobj = 0;
52561 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52562 int result;
52563 void *argp1 = 0 ;
52564 int res1 = 0 ;
52565 PyObject *swig_obj[1] ;
52566
52567 if (!args) SWIG_fail;
52568 swig_obj[0] = args;
52569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52570 if (!SWIG_IsOK(res1)) {
52571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52572 }
52573 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52574 {
52575 PyThreadState* __tstate = wxPyBeginAllowThreads();
52576 result = (int)((wxGBPosition const *)arg1)->GetRow();
52577 wxPyEndAllowThreads(__tstate);
52578 if (PyErr_Occurred()) SWIG_fail;
52579 }
52580 resultobj = SWIG_From_int(static_cast< int >(result));
52581 return resultobj;
52582 fail:
52583 return NULL;
52584 }
52585
52586
52587 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52588 PyObject *resultobj = 0;
52589 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52590 int result;
52591 void *argp1 = 0 ;
52592 int res1 = 0 ;
52593 PyObject *swig_obj[1] ;
52594
52595 if (!args) SWIG_fail;
52596 swig_obj[0] = args;
52597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52598 if (!SWIG_IsOK(res1)) {
52599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52600 }
52601 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52602 {
52603 PyThreadState* __tstate = wxPyBeginAllowThreads();
52604 result = (int)((wxGBPosition const *)arg1)->GetCol();
52605 wxPyEndAllowThreads(__tstate);
52606 if (PyErr_Occurred()) SWIG_fail;
52607 }
52608 resultobj = SWIG_From_int(static_cast< int >(result));
52609 return resultobj;
52610 fail:
52611 return NULL;
52612 }
52613
52614
52615 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52616 PyObject *resultobj = 0;
52617 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52618 int arg2 ;
52619 void *argp1 = 0 ;
52620 int res1 = 0 ;
52621 int val2 ;
52622 int ecode2 = 0 ;
52623 PyObject * obj0 = 0 ;
52624 PyObject * obj1 = 0 ;
52625 char * kwnames[] = {
52626 (char *) "self",(char *) "row", NULL
52627 };
52628
52629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52631 if (!SWIG_IsOK(res1)) {
52632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52633 }
52634 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52635 ecode2 = SWIG_AsVal_int(obj1, &val2);
52636 if (!SWIG_IsOK(ecode2)) {
52637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52638 }
52639 arg2 = static_cast< int >(val2);
52640 {
52641 PyThreadState* __tstate = wxPyBeginAllowThreads();
52642 (arg1)->SetRow(arg2);
52643 wxPyEndAllowThreads(__tstate);
52644 if (PyErr_Occurred()) SWIG_fail;
52645 }
52646 resultobj = SWIG_Py_Void();
52647 return resultobj;
52648 fail:
52649 return NULL;
52650 }
52651
52652
52653 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52654 PyObject *resultobj = 0;
52655 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52656 int arg2 ;
52657 void *argp1 = 0 ;
52658 int res1 = 0 ;
52659 int val2 ;
52660 int ecode2 = 0 ;
52661 PyObject * obj0 = 0 ;
52662 PyObject * obj1 = 0 ;
52663 char * kwnames[] = {
52664 (char *) "self",(char *) "col", NULL
52665 };
52666
52667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52669 if (!SWIG_IsOK(res1)) {
52670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52671 }
52672 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52673 ecode2 = SWIG_AsVal_int(obj1, &val2);
52674 if (!SWIG_IsOK(ecode2)) {
52675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52676 }
52677 arg2 = static_cast< int >(val2);
52678 {
52679 PyThreadState* __tstate = wxPyBeginAllowThreads();
52680 (arg1)->SetCol(arg2);
52681 wxPyEndAllowThreads(__tstate);
52682 if (PyErr_Occurred()) SWIG_fail;
52683 }
52684 resultobj = SWIG_Py_Void();
52685 return resultobj;
52686 fail:
52687 return NULL;
52688 }
52689
52690
52691 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52692 PyObject *resultobj = 0;
52693 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52694 PyObject *arg2 = (PyObject *) 0 ;
52695 bool result;
52696 void *argp1 = 0 ;
52697 int res1 = 0 ;
52698 PyObject * obj0 = 0 ;
52699 PyObject * obj1 = 0 ;
52700 char * kwnames[] = {
52701 (char *) "self",(char *) "other", NULL
52702 };
52703
52704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52706 if (!SWIG_IsOK(res1)) {
52707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52708 }
52709 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52710 arg2 = obj1;
52711 {
52712 result = (bool)wxGBPosition___eq__(arg1,arg2);
52713 if (PyErr_Occurred()) SWIG_fail;
52714 }
52715 {
52716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52717 }
52718 return resultobj;
52719 fail:
52720 return NULL;
52721 }
52722
52723
52724 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52725 PyObject *resultobj = 0;
52726 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52727 PyObject *arg2 = (PyObject *) 0 ;
52728 bool result;
52729 void *argp1 = 0 ;
52730 int res1 = 0 ;
52731 PyObject * obj0 = 0 ;
52732 PyObject * obj1 = 0 ;
52733 char * kwnames[] = {
52734 (char *) "self",(char *) "other", NULL
52735 };
52736
52737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52739 if (!SWIG_IsOK(res1)) {
52740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52741 }
52742 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52743 arg2 = obj1;
52744 {
52745 result = (bool)wxGBPosition___ne__(arg1,arg2);
52746 if (PyErr_Occurred()) SWIG_fail;
52747 }
52748 {
52749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52750 }
52751 return resultobj;
52752 fail:
52753 return NULL;
52754 }
52755
52756
52757 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52758 PyObject *resultobj = 0;
52759 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52760 int arg2 = (int) 0 ;
52761 int arg3 = (int) 0 ;
52762 void *argp1 = 0 ;
52763 int res1 = 0 ;
52764 int val2 ;
52765 int ecode2 = 0 ;
52766 int val3 ;
52767 int ecode3 = 0 ;
52768 PyObject * obj0 = 0 ;
52769 PyObject * obj1 = 0 ;
52770 PyObject * obj2 = 0 ;
52771 char * kwnames[] = {
52772 (char *) "self",(char *) "row",(char *) "col", NULL
52773 };
52774
52775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52777 if (!SWIG_IsOK(res1)) {
52778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52779 }
52780 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52781 if (obj1) {
52782 ecode2 = SWIG_AsVal_int(obj1, &val2);
52783 if (!SWIG_IsOK(ecode2)) {
52784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52785 }
52786 arg2 = static_cast< int >(val2);
52787 }
52788 if (obj2) {
52789 ecode3 = SWIG_AsVal_int(obj2, &val3);
52790 if (!SWIG_IsOK(ecode3)) {
52791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52792 }
52793 arg3 = static_cast< int >(val3);
52794 }
52795 {
52796 PyThreadState* __tstate = wxPyBeginAllowThreads();
52797 wxGBPosition_Set(arg1,arg2,arg3);
52798 wxPyEndAllowThreads(__tstate);
52799 if (PyErr_Occurred()) SWIG_fail;
52800 }
52801 resultobj = SWIG_Py_Void();
52802 return resultobj;
52803 fail:
52804 return NULL;
52805 }
52806
52807
52808 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52809 PyObject *resultobj = 0;
52810 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52811 PyObject *result = 0 ;
52812 void *argp1 = 0 ;
52813 int res1 = 0 ;
52814 PyObject *swig_obj[1] ;
52815
52816 if (!args) SWIG_fail;
52817 swig_obj[0] = args;
52818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52819 if (!SWIG_IsOK(res1)) {
52820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52821 }
52822 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52823 {
52824 PyThreadState* __tstate = wxPyBeginAllowThreads();
52825 result = (PyObject *)wxGBPosition_Get(arg1);
52826 wxPyEndAllowThreads(__tstate);
52827 if (PyErr_Occurred()) SWIG_fail;
52828 }
52829 resultobj = result;
52830 return resultobj;
52831 fail:
52832 return NULL;
52833 }
52834
52835
52836 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52837 PyObject *obj;
52838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52839 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52840 return SWIG_Py_Void();
52841 }
52842
52843 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52844 return SWIG_Python_InitShadowInstance(args);
52845 }
52846
52847 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52848 PyObject *resultobj = 0;
52849 int arg1 = (int) 1 ;
52850 int arg2 = (int) 1 ;
52851 wxGBSpan *result = 0 ;
52852 int val1 ;
52853 int ecode1 = 0 ;
52854 int val2 ;
52855 int ecode2 = 0 ;
52856 PyObject * obj0 = 0 ;
52857 PyObject * obj1 = 0 ;
52858 char * kwnames[] = {
52859 (char *) "rowspan",(char *) "colspan", NULL
52860 };
52861
52862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52863 if (obj0) {
52864 ecode1 = SWIG_AsVal_int(obj0, &val1);
52865 if (!SWIG_IsOK(ecode1)) {
52866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52867 }
52868 arg1 = static_cast< int >(val1);
52869 }
52870 if (obj1) {
52871 ecode2 = SWIG_AsVal_int(obj1, &val2);
52872 if (!SWIG_IsOK(ecode2)) {
52873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52874 }
52875 arg2 = static_cast< int >(val2);
52876 }
52877 {
52878 PyThreadState* __tstate = wxPyBeginAllowThreads();
52879 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52880 wxPyEndAllowThreads(__tstate);
52881 if (PyErr_Occurred()) SWIG_fail;
52882 }
52883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52884 return resultobj;
52885 fail:
52886 return NULL;
52887 }
52888
52889
52890 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52891 PyObject *resultobj = 0;
52892 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52893 void *argp1 = 0 ;
52894 int res1 = 0 ;
52895 PyObject *swig_obj[1] ;
52896
52897 if (!args) SWIG_fail;
52898 swig_obj[0] = args;
52899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52900 if (!SWIG_IsOK(res1)) {
52901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52902 }
52903 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52904 {
52905 PyThreadState* __tstate = wxPyBeginAllowThreads();
52906 delete arg1;
52907
52908 wxPyEndAllowThreads(__tstate);
52909 if (PyErr_Occurred()) SWIG_fail;
52910 }
52911 resultobj = SWIG_Py_Void();
52912 return resultobj;
52913 fail:
52914 return NULL;
52915 }
52916
52917
52918 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52919 PyObject *resultobj = 0;
52920 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52921 int result;
52922 void *argp1 = 0 ;
52923 int res1 = 0 ;
52924 PyObject *swig_obj[1] ;
52925
52926 if (!args) SWIG_fail;
52927 swig_obj[0] = args;
52928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52929 if (!SWIG_IsOK(res1)) {
52930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52931 }
52932 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52933 {
52934 PyThreadState* __tstate = wxPyBeginAllowThreads();
52935 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52936 wxPyEndAllowThreads(__tstate);
52937 if (PyErr_Occurred()) SWIG_fail;
52938 }
52939 resultobj = SWIG_From_int(static_cast< int >(result));
52940 return resultobj;
52941 fail:
52942 return NULL;
52943 }
52944
52945
52946 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52947 PyObject *resultobj = 0;
52948 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52949 int result;
52950 void *argp1 = 0 ;
52951 int res1 = 0 ;
52952 PyObject *swig_obj[1] ;
52953
52954 if (!args) SWIG_fail;
52955 swig_obj[0] = args;
52956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52957 if (!SWIG_IsOK(res1)) {
52958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52959 }
52960 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52961 {
52962 PyThreadState* __tstate = wxPyBeginAllowThreads();
52963 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52964 wxPyEndAllowThreads(__tstate);
52965 if (PyErr_Occurred()) SWIG_fail;
52966 }
52967 resultobj = SWIG_From_int(static_cast< int >(result));
52968 return resultobj;
52969 fail:
52970 return NULL;
52971 }
52972
52973
52974 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52975 PyObject *resultobj = 0;
52976 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52977 int arg2 ;
52978 void *argp1 = 0 ;
52979 int res1 = 0 ;
52980 int val2 ;
52981 int ecode2 = 0 ;
52982 PyObject * obj0 = 0 ;
52983 PyObject * obj1 = 0 ;
52984 char * kwnames[] = {
52985 (char *) "self",(char *) "rowspan", NULL
52986 };
52987
52988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
52989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52990 if (!SWIG_IsOK(res1)) {
52991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52992 }
52993 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52994 ecode2 = SWIG_AsVal_int(obj1, &val2);
52995 if (!SWIG_IsOK(ecode2)) {
52996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
52997 }
52998 arg2 = static_cast< int >(val2);
52999 {
53000 PyThreadState* __tstate = wxPyBeginAllowThreads();
53001 (arg1)->SetRowspan(arg2);
53002 wxPyEndAllowThreads(__tstate);
53003 if (PyErr_Occurred()) SWIG_fail;
53004 }
53005 resultobj = SWIG_Py_Void();
53006 return resultobj;
53007 fail:
53008 return NULL;
53009 }
53010
53011
53012 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53013 PyObject *resultobj = 0;
53014 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53015 int arg2 ;
53016 void *argp1 = 0 ;
53017 int res1 = 0 ;
53018 int val2 ;
53019 int ecode2 = 0 ;
53020 PyObject * obj0 = 0 ;
53021 PyObject * obj1 = 0 ;
53022 char * kwnames[] = {
53023 (char *) "self",(char *) "colspan", NULL
53024 };
53025
53026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53028 if (!SWIG_IsOK(res1)) {
53029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53030 }
53031 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53032 ecode2 = SWIG_AsVal_int(obj1, &val2);
53033 if (!SWIG_IsOK(ecode2)) {
53034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53035 }
53036 arg2 = static_cast< int >(val2);
53037 {
53038 PyThreadState* __tstate = wxPyBeginAllowThreads();
53039 (arg1)->SetColspan(arg2);
53040 wxPyEndAllowThreads(__tstate);
53041 if (PyErr_Occurred()) SWIG_fail;
53042 }
53043 resultobj = SWIG_Py_Void();
53044 return resultobj;
53045 fail:
53046 return NULL;
53047 }
53048
53049
53050 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53051 PyObject *resultobj = 0;
53052 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53053 PyObject *arg2 = (PyObject *) 0 ;
53054 bool result;
53055 void *argp1 = 0 ;
53056 int res1 = 0 ;
53057 PyObject * obj0 = 0 ;
53058 PyObject * obj1 = 0 ;
53059 char * kwnames[] = {
53060 (char *) "self",(char *) "other", NULL
53061 };
53062
53063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53065 if (!SWIG_IsOK(res1)) {
53066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53067 }
53068 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53069 arg2 = obj1;
53070 {
53071 result = (bool)wxGBSpan___eq__(arg1,arg2);
53072 if (PyErr_Occurred()) SWIG_fail;
53073 }
53074 {
53075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53076 }
53077 return resultobj;
53078 fail:
53079 return NULL;
53080 }
53081
53082
53083 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53084 PyObject *resultobj = 0;
53085 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53086 PyObject *arg2 = (PyObject *) 0 ;
53087 bool result;
53088 void *argp1 = 0 ;
53089 int res1 = 0 ;
53090 PyObject * obj0 = 0 ;
53091 PyObject * obj1 = 0 ;
53092 char * kwnames[] = {
53093 (char *) "self",(char *) "other", NULL
53094 };
53095
53096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53098 if (!SWIG_IsOK(res1)) {
53099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53100 }
53101 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53102 arg2 = obj1;
53103 {
53104 result = (bool)wxGBSpan___ne__(arg1,arg2);
53105 if (PyErr_Occurred()) SWIG_fail;
53106 }
53107 {
53108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53109 }
53110 return resultobj;
53111 fail:
53112 return NULL;
53113 }
53114
53115
53116 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53117 PyObject *resultobj = 0;
53118 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53119 int arg2 = (int) 1 ;
53120 int arg3 = (int) 1 ;
53121 void *argp1 = 0 ;
53122 int res1 = 0 ;
53123 int val2 ;
53124 int ecode2 = 0 ;
53125 int val3 ;
53126 int ecode3 = 0 ;
53127 PyObject * obj0 = 0 ;
53128 PyObject * obj1 = 0 ;
53129 PyObject * obj2 = 0 ;
53130 char * kwnames[] = {
53131 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53132 };
53133
53134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53136 if (!SWIG_IsOK(res1)) {
53137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53138 }
53139 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53140 if (obj1) {
53141 ecode2 = SWIG_AsVal_int(obj1, &val2);
53142 if (!SWIG_IsOK(ecode2)) {
53143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53144 }
53145 arg2 = static_cast< int >(val2);
53146 }
53147 if (obj2) {
53148 ecode3 = SWIG_AsVal_int(obj2, &val3);
53149 if (!SWIG_IsOK(ecode3)) {
53150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53151 }
53152 arg3 = static_cast< int >(val3);
53153 }
53154 {
53155 PyThreadState* __tstate = wxPyBeginAllowThreads();
53156 wxGBSpan_Set(arg1,arg2,arg3);
53157 wxPyEndAllowThreads(__tstate);
53158 if (PyErr_Occurred()) SWIG_fail;
53159 }
53160 resultobj = SWIG_Py_Void();
53161 return resultobj;
53162 fail:
53163 return NULL;
53164 }
53165
53166
53167 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53168 PyObject *resultobj = 0;
53169 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53170 PyObject *result = 0 ;
53171 void *argp1 = 0 ;
53172 int res1 = 0 ;
53173 PyObject *swig_obj[1] ;
53174
53175 if (!args) SWIG_fail;
53176 swig_obj[0] = args;
53177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53178 if (!SWIG_IsOK(res1)) {
53179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53180 }
53181 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53182 {
53183 PyThreadState* __tstate = wxPyBeginAllowThreads();
53184 result = (PyObject *)wxGBSpan_Get(arg1);
53185 wxPyEndAllowThreads(__tstate);
53186 if (PyErr_Occurred()) SWIG_fail;
53187 }
53188 resultobj = result;
53189 return resultobj;
53190 fail:
53191 return NULL;
53192 }
53193
53194
53195 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53196 PyObject *obj;
53197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53198 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53199 return SWIG_Py_Void();
53200 }
53201
53202 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53203 return SWIG_Python_InitShadowInstance(args);
53204 }
53205
53206 SWIGINTERN int DefaultSpan_set(PyObject *) {
53207 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53208 return 1;
53209 }
53210
53211
53212 SWIGINTERN PyObject *DefaultSpan_get(void) {
53213 PyObject *pyobj = 0;
53214
53215 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53216 return pyobj;
53217 }
53218
53219
53220 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53221 PyObject *resultobj = 0;
53222 wxGBSizerItem *result = 0 ;
53223
53224 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53225 {
53226 PyThreadState* __tstate = wxPyBeginAllowThreads();
53227 result = (wxGBSizerItem *)new wxGBSizerItem();
53228 wxPyEndAllowThreads(__tstate);
53229 if (PyErr_Occurred()) SWIG_fail;
53230 }
53231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53232 return resultobj;
53233 fail:
53234 return NULL;
53235 }
53236
53237
53238 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53239 PyObject *resultobj = 0;
53240 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53241 void *argp1 = 0 ;
53242 int res1 = 0 ;
53243 PyObject *swig_obj[1] ;
53244
53245 if (!args) SWIG_fail;
53246 swig_obj[0] = args;
53247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53248 if (!SWIG_IsOK(res1)) {
53249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53250 }
53251 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53252 {
53253 PyThreadState* __tstate = wxPyBeginAllowThreads();
53254 delete arg1;
53255
53256 wxPyEndAllowThreads(__tstate);
53257 if (PyErr_Occurred()) SWIG_fail;
53258 }
53259 resultobj = SWIG_Py_Void();
53260 return resultobj;
53261 fail:
53262 return NULL;
53263 }
53264
53265
53266 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53267 PyObject *resultobj = 0;
53268 wxWindow *arg1 = (wxWindow *) 0 ;
53269 wxGBPosition *arg2 = 0 ;
53270 wxGBSpan *arg3 = 0 ;
53271 int arg4 ;
53272 int arg5 ;
53273 PyObject *arg6 = (PyObject *) NULL ;
53274 wxGBSizerItem *result = 0 ;
53275 void *argp1 = 0 ;
53276 int res1 = 0 ;
53277 wxGBPosition temp2 ;
53278 wxGBSpan temp3 ;
53279 int val4 ;
53280 int ecode4 = 0 ;
53281 int val5 ;
53282 int ecode5 = 0 ;
53283 PyObject * obj0 = 0 ;
53284 PyObject * obj1 = 0 ;
53285 PyObject * obj2 = 0 ;
53286 PyObject * obj3 = 0 ;
53287 PyObject * obj4 = 0 ;
53288 PyObject * obj5 = 0 ;
53289 char * kwnames[] = {
53290 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53291 };
53292
53293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53295 if (!SWIG_IsOK(res1)) {
53296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53297 }
53298 arg1 = reinterpret_cast< wxWindow * >(argp1);
53299 {
53300 arg2 = &temp2;
53301 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53302 }
53303 {
53304 arg3 = &temp3;
53305 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53306 }
53307 ecode4 = SWIG_AsVal_int(obj3, &val4);
53308 if (!SWIG_IsOK(ecode4)) {
53309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53310 }
53311 arg4 = static_cast< int >(val4);
53312 ecode5 = SWIG_AsVal_int(obj4, &val5);
53313 if (!SWIG_IsOK(ecode5)) {
53314 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53315 }
53316 arg5 = static_cast< int >(val5);
53317 if (obj5) {
53318 arg6 = obj5;
53319 }
53320 {
53321 PyThreadState* __tstate = wxPyBeginAllowThreads();
53322 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53323 wxPyEndAllowThreads(__tstate);
53324 if (PyErr_Occurred()) SWIG_fail;
53325 }
53326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53327 return resultobj;
53328 fail:
53329 return NULL;
53330 }
53331
53332
53333 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53334 PyObject *resultobj = 0;
53335 wxSizer *arg1 = (wxSizer *) 0 ;
53336 wxGBPosition *arg2 = 0 ;
53337 wxGBSpan *arg3 = 0 ;
53338 int arg4 ;
53339 int arg5 ;
53340 PyObject *arg6 = (PyObject *) NULL ;
53341 wxGBSizerItem *result = 0 ;
53342 int res1 = 0 ;
53343 wxGBPosition temp2 ;
53344 wxGBSpan temp3 ;
53345 int val4 ;
53346 int ecode4 = 0 ;
53347 int val5 ;
53348 int ecode5 = 0 ;
53349 PyObject * obj0 = 0 ;
53350 PyObject * obj1 = 0 ;
53351 PyObject * obj2 = 0 ;
53352 PyObject * obj3 = 0 ;
53353 PyObject * obj4 = 0 ;
53354 PyObject * obj5 = 0 ;
53355 char * kwnames[] = {
53356 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53357 };
53358
53359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53360 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53361 if (!SWIG_IsOK(res1)) {
53362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53363 }
53364 {
53365 arg2 = &temp2;
53366 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53367 }
53368 {
53369 arg3 = &temp3;
53370 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53371 }
53372 ecode4 = SWIG_AsVal_int(obj3, &val4);
53373 if (!SWIG_IsOK(ecode4)) {
53374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53375 }
53376 arg4 = static_cast< int >(val4);
53377 ecode5 = SWIG_AsVal_int(obj4, &val5);
53378 if (!SWIG_IsOK(ecode5)) {
53379 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53380 }
53381 arg5 = static_cast< int >(val5);
53382 if (obj5) {
53383 arg6 = obj5;
53384 }
53385 {
53386 PyThreadState* __tstate = wxPyBeginAllowThreads();
53387 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53388 wxPyEndAllowThreads(__tstate);
53389 if (PyErr_Occurred()) SWIG_fail;
53390 }
53391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53392 return resultobj;
53393 fail:
53394 return NULL;
53395 }
53396
53397
53398 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53399 PyObject *resultobj = 0;
53400 int arg1 ;
53401 int arg2 ;
53402 wxGBPosition *arg3 = 0 ;
53403 wxGBSpan *arg4 = 0 ;
53404 int arg5 ;
53405 int arg6 ;
53406 PyObject *arg7 = (PyObject *) NULL ;
53407 wxGBSizerItem *result = 0 ;
53408 int val1 ;
53409 int ecode1 = 0 ;
53410 int val2 ;
53411 int ecode2 = 0 ;
53412 wxGBPosition temp3 ;
53413 wxGBSpan temp4 ;
53414 int val5 ;
53415 int ecode5 = 0 ;
53416 int val6 ;
53417 int ecode6 = 0 ;
53418 PyObject * obj0 = 0 ;
53419 PyObject * obj1 = 0 ;
53420 PyObject * obj2 = 0 ;
53421 PyObject * obj3 = 0 ;
53422 PyObject * obj4 = 0 ;
53423 PyObject * obj5 = 0 ;
53424 PyObject * obj6 = 0 ;
53425 char * kwnames[] = {
53426 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53427 };
53428
53429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53430 ecode1 = SWIG_AsVal_int(obj0, &val1);
53431 if (!SWIG_IsOK(ecode1)) {
53432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53433 }
53434 arg1 = static_cast< int >(val1);
53435 ecode2 = SWIG_AsVal_int(obj1, &val2);
53436 if (!SWIG_IsOK(ecode2)) {
53437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53438 }
53439 arg2 = static_cast< int >(val2);
53440 {
53441 arg3 = &temp3;
53442 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53443 }
53444 {
53445 arg4 = &temp4;
53446 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53447 }
53448 ecode5 = SWIG_AsVal_int(obj4, &val5);
53449 if (!SWIG_IsOK(ecode5)) {
53450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53451 }
53452 arg5 = static_cast< int >(val5);
53453 ecode6 = SWIG_AsVal_int(obj5, &val6);
53454 if (!SWIG_IsOK(ecode6)) {
53455 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53456 }
53457 arg6 = static_cast< int >(val6);
53458 if (obj6) {
53459 arg7 = obj6;
53460 }
53461 {
53462 PyThreadState* __tstate = wxPyBeginAllowThreads();
53463 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53464 wxPyEndAllowThreads(__tstate);
53465 if (PyErr_Occurred()) SWIG_fail;
53466 }
53467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53468 return resultobj;
53469 fail:
53470 return NULL;
53471 }
53472
53473
53474 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53475 PyObject *resultobj = 0;
53476 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53477 wxGBPosition result;
53478 void *argp1 = 0 ;
53479 int res1 = 0 ;
53480 PyObject *swig_obj[1] ;
53481
53482 if (!args) SWIG_fail;
53483 swig_obj[0] = args;
53484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53485 if (!SWIG_IsOK(res1)) {
53486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53487 }
53488 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53489 {
53490 PyThreadState* __tstate = wxPyBeginAllowThreads();
53491 result = ((wxGBSizerItem const *)arg1)->GetPos();
53492 wxPyEndAllowThreads(__tstate);
53493 if (PyErr_Occurred()) SWIG_fail;
53494 }
53495 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53496 return resultobj;
53497 fail:
53498 return NULL;
53499 }
53500
53501
53502 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53503 PyObject *resultobj = 0;
53504 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53505 wxGBSpan result;
53506 void *argp1 = 0 ;
53507 int res1 = 0 ;
53508 PyObject *swig_obj[1] ;
53509
53510 if (!args) SWIG_fail;
53511 swig_obj[0] = args;
53512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53513 if (!SWIG_IsOK(res1)) {
53514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53515 }
53516 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53517 {
53518 PyThreadState* __tstate = wxPyBeginAllowThreads();
53519 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53520 wxPyEndAllowThreads(__tstate);
53521 if (PyErr_Occurred()) SWIG_fail;
53522 }
53523 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53524 return resultobj;
53525 fail:
53526 return NULL;
53527 }
53528
53529
53530 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53531 PyObject *resultobj = 0;
53532 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53533 wxGBPosition *arg2 = 0 ;
53534 bool result;
53535 void *argp1 = 0 ;
53536 int res1 = 0 ;
53537 wxGBPosition temp2 ;
53538 PyObject * obj0 = 0 ;
53539 PyObject * obj1 = 0 ;
53540 char * kwnames[] = {
53541 (char *) "self",(char *) "pos", NULL
53542 };
53543
53544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53546 if (!SWIG_IsOK(res1)) {
53547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53548 }
53549 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53550 {
53551 arg2 = &temp2;
53552 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53553 }
53554 {
53555 PyThreadState* __tstate = wxPyBeginAllowThreads();
53556 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53557 wxPyEndAllowThreads(__tstate);
53558 if (PyErr_Occurred()) SWIG_fail;
53559 }
53560 {
53561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53562 }
53563 return resultobj;
53564 fail:
53565 return NULL;
53566 }
53567
53568
53569 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53570 PyObject *resultobj = 0;
53571 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53572 wxGBSpan *arg2 = 0 ;
53573 bool result;
53574 void *argp1 = 0 ;
53575 int res1 = 0 ;
53576 wxGBSpan temp2 ;
53577 PyObject * obj0 = 0 ;
53578 PyObject * obj1 = 0 ;
53579 char * kwnames[] = {
53580 (char *) "self",(char *) "span", NULL
53581 };
53582
53583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53585 if (!SWIG_IsOK(res1)) {
53586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53587 }
53588 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53589 {
53590 arg2 = &temp2;
53591 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53592 }
53593 {
53594 PyThreadState* __tstate = wxPyBeginAllowThreads();
53595 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53596 wxPyEndAllowThreads(__tstate);
53597 if (PyErr_Occurred()) SWIG_fail;
53598 }
53599 {
53600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53601 }
53602 return resultobj;
53603 fail:
53604 return NULL;
53605 }
53606
53607
53608 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53609 PyObject *resultobj = 0;
53610 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53611 wxGBSizerItem *arg2 = 0 ;
53612 bool result;
53613 void *argp1 = 0 ;
53614 int res1 = 0 ;
53615 void *argp2 = 0 ;
53616 int res2 = 0 ;
53617 PyObject * obj0 = 0 ;
53618 PyObject * obj1 = 0 ;
53619 char * kwnames[] = {
53620 (char *) "self",(char *) "other", NULL
53621 };
53622
53623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53625 if (!SWIG_IsOK(res1)) {
53626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53627 }
53628 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53629 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53630 if (!SWIG_IsOK(res2)) {
53631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53632 }
53633 if (!argp2) {
53634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53635 }
53636 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53637 {
53638 PyThreadState* __tstate = wxPyBeginAllowThreads();
53639 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53640 wxPyEndAllowThreads(__tstate);
53641 if (PyErr_Occurred()) SWIG_fail;
53642 }
53643 {
53644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53645 }
53646 return resultobj;
53647 fail:
53648 return NULL;
53649 }
53650
53651
53652 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53653 PyObject *resultobj = 0;
53654 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53655 wxGBPosition *arg2 = 0 ;
53656 wxGBSpan *arg3 = 0 ;
53657 bool result;
53658 void *argp1 = 0 ;
53659 int res1 = 0 ;
53660 wxGBPosition temp2 ;
53661 wxGBSpan temp3 ;
53662 PyObject * obj0 = 0 ;
53663 PyObject * obj1 = 0 ;
53664 PyObject * obj2 = 0 ;
53665 char * kwnames[] = {
53666 (char *) "self",(char *) "pos",(char *) "span", NULL
53667 };
53668
53669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53671 if (!SWIG_IsOK(res1)) {
53672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53673 }
53674 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53675 {
53676 arg2 = &temp2;
53677 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53678 }
53679 {
53680 arg3 = &temp3;
53681 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53682 }
53683 {
53684 PyThreadState* __tstate = wxPyBeginAllowThreads();
53685 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53686 wxPyEndAllowThreads(__tstate);
53687 if (PyErr_Occurred()) SWIG_fail;
53688 }
53689 {
53690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53691 }
53692 return resultobj;
53693 fail:
53694 return NULL;
53695 }
53696
53697
53698 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53699 PyObject *resultobj = 0;
53700 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53701 wxGBPosition result;
53702 void *argp1 = 0 ;
53703 int res1 = 0 ;
53704 PyObject *swig_obj[1] ;
53705
53706 if (!args) SWIG_fail;
53707 swig_obj[0] = args;
53708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53709 if (!SWIG_IsOK(res1)) {
53710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53711 }
53712 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53713 {
53714 PyThreadState* __tstate = wxPyBeginAllowThreads();
53715 result = wxGBSizerItem_GetEndPos(arg1);
53716 wxPyEndAllowThreads(__tstate);
53717 if (PyErr_Occurred()) SWIG_fail;
53718 }
53719 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53720 return resultobj;
53721 fail:
53722 return NULL;
53723 }
53724
53725
53726 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53727 PyObject *resultobj = 0;
53728 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53729 wxGridBagSizer *result = 0 ;
53730 void *argp1 = 0 ;
53731 int res1 = 0 ;
53732 PyObject *swig_obj[1] ;
53733
53734 if (!args) SWIG_fail;
53735 swig_obj[0] = args;
53736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53737 if (!SWIG_IsOK(res1)) {
53738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53739 }
53740 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53741 {
53742 PyThreadState* __tstate = wxPyBeginAllowThreads();
53743 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53744 wxPyEndAllowThreads(__tstate);
53745 if (PyErr_Occurred()) SWIG_fail;
53746 }
53747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53748 return resultobj;
53749 fail:
53750 return NULL;
53751 }
53752
53753
53754 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53755 PyObject *resultobj = 0;
53756 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53757 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53758 void *argp1 = 0 ;
53759 int res1 = 0 ;
53760 void *argp2 = 0 ;
53761 int res2 = 0 ;
53762 PyObject * obj0 = 0 ;
53763 PyObject * obj1 = 0 ;
53764 char * kwnames[] = {
53765 (char *) "self",(char *) "sizer", NULL
53766 };
53767
53768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53770 if (!SWIG_IsOK(res1)) {
53771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53772 }
53773 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53775 if (!SWIG_IsOK(res2)) {
53776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53777 }
53778 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53779 {
53780 PyThreadState* __tstate = wxPyBeginAllowThreads();
53781 (arg1)->SetGBSizer(arg2);
53782 wxPyEndAllowThreads(__tstate);
53783 if (PyErr_Occurred()) SWIG_fail;
53784 }
53785 resultobj = SWIG_Py_Void();
53786 return resultobj;
53787 fail:
53788 return NULL;
53789 }
53790
53791
53792 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53793 PyObject *obj;
53794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53795 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53796 return SWIG_Py_Void();
53797 }
53798
53799 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53800 return SWIG_Python_InitShadowInstance(args);
53801 }
53802
53803 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53804 PyObject *resultobj = 0;
53805 int arg1 = (int) 0 ;
53806 int arg2 = (int) 0 ;
53807 wxGridBagSizer *result = 0 ;
53808 int val1 ;
53809 int ecode1 = 0 ;
53810 int val2 ;
53811 int ecode2 = 0 ;
53812 PyObject * obj0 = 0 ;
53813 PyObject * obj1 = 0 ;
53814 char * kwnames[] = {
53815 (char *) "vgap",(char *) "hgap", NULL
53816 };
53817
53818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53819 if (obj0) {
53820 ecode1 = SWIG_AsVal_int(obj0, &val1);
53821 if (!SWIG_IsOK(ecode1)) {
53822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53823 }
53824 arg1 = static_cast< int >(val1);
53825 }
53826 if (obj1) {
53827 ecode2 = SWIG_AsVal_int(obj1, &val2);
53828 if (!SWIG_IsOK(ecode2)) {
53829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53830 }
53831 arg2 = static_cast< int >(val2);
53832 }
53833 {
53834 PyThreadState* __tstate = wxPyBeginAllowThreads();
53835 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53836 wxPyEndAllowThreads(__tstate);
53837 if (PyErr_Occurred()) SWIG_fail;
53838 }
53839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53840 return resultobj;
53841 fail:
53842 return NULL;
53843 }
53844
53845
53846 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53847 PyObject *resultobj = 0;
53848 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53849 PyObject *arg2 = (PyObject *) 0 ;
53850 wxGBPosition *arg3 = 0 ;
53851 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53852 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53853 int arg5 = (int) 0 ;
53854 int arg6 = (int) 0 ;
53855 PyObject *arg7 = (PyObject *) NULL ;
53856 wxGBSizerItem *result = 0 ;
53857 void *argp1 = 0 ;
53858 int res1 = 0 ;
53859 wxGBPosition temp3 ;
53860 wxGBSpan temp4 ;
53861 int val5 ;
53862 int ecode5 = 0 ;
53863 int val6 ;
53864 int ecode6 = 0 ;
53865 PyObject * obj0 = 0 ;
53866 PyObject * obj1 = 0 ;
53867 PyObject * obj2 = 0 ;
53868 PyObject * obj3 = 0 ;
53869 PyObject * obj4 = 0 ;
53870 PyObject * obj5 = 0 ;
53871 PyObject * obj6 = 0 ;
53872 char * kwnames[] = {
53873 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53874 };
53875
53876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53878 if (!SWIG_IsOK(res1)) {
53879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53880 }
53881 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53882 arg2 = obj1;
53883 {
53884 arg3 = &temp3;
53885 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53886 }
53887 if (obj3) {
53888 {
53889 arg4 = &temp4;
53890 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53891 }
53892 }
53893 if (obj4) {
53894 ecode5 = SWIG_AsVal_int(obj4, &val5);
53895 if (!SWIG_IsOK(ecode5)) {
53896 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53897 }
53898 arg5 = static_cast< int >(val5);
53899 }
53900 if (obj5) {
53901 ecode6 = SWIG_AsVal_int(obj5, &val6);
53902 if (!SWIG_IsOK(ecode6)) {
53903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53904 }
53905 arg6 = static_cast< int >(val6);
53906 }
53907 if (obj6) {
53908 arg7 = obj6;
53909 }
53910 {
53911 PyThreadState* __tstate = wxPyBeginAllowThreads();
53912 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53913 wxPyEndAllowThreads(__tstate);
53914 if (PyErr_Occurred()) SWIG_fail;
53915 }
53916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53917 return resultobj;
53918 fail:
53919 return NULL;
53920 }
53921
53922
53923 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53924 PyObject *resultobj = 0;
53925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53926 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53927 wxGBSizerItem *result = 0 ;
53928 void *argp1 = 0 ;
53929 int res1 = 0 ;
53930 int res2 = 0 ;
53931 PyObject * obj0 = 0 ;
53932 PyObject * obj1 = 0 ;
53933 char * kwnames[] = {
53934 (char *) "self",(char *) "item", NULL
53935 };
53936
53937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53939 if (!SWIG_IsOK(res1)) {
53940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53941 }
53942 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53943 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53944 if (!SWIG_IsOK(res2)) {
53945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53946 }
53947 {
53948 PyThreadState* __tstate = wxPyBeginAllowThreads();
53949 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53950 wxPyEndAllowThreads(__tstate);
53951 if (PyErr_Occurred()) SWIG_fail;
53952 }
53953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53954 return resultobj;
53955 fail:
53956 return NULL;
53957 }
53958
53959
53960 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53961 PyObject *resultobj = 0;
53962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53963 int arg2 ;
53964 int arg3 ;
53965 wxSize result;
53966 void *argp1 = 0 ;
53967 int res1 = 0 ;
53968 int val2 ;
53969 int ecode2 = 0 ;
53970 int val3 ;
53971 int ecode3 = 0 ;
53972 PyObject * obj0 = 0 ;
53973 PyObject * obj1 = 0 ;
53974 PyObject * obj2 = 0 ;
53975 char * kwnames[] = {
53976 (char *) "self",(char *) "row",(char *) "col", NULL
53977 };
53978
53979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53981 if (!SWIG_IsOK(res1)) {
53982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53983 }
53984 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53985 ecode2 = SWIG_AsVal_int(obj1, &val2);
53986 if (!SWIG_IsOK(ecode2)) {
53987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
53988 }
53989 arg2 = static_cast< int >(val2);
53990 ecode3 = SWIG_AsVal_int(obj2, &val3);
53991 if (!SWIG_IsOK(ecode3)) {
53992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
53993 }
53994 arg3 = static_cast< int >(val3);
53995 {
53996 PyThreadState* __tstate = wxPyBeginAllowThreads();
53997 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
53998 wxPyEndAllowThreads(__tstate);
53999 if (PyErr_Occurred()) SWIG_fail;
54000 }
54001 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54002 return resultobj;
54003 fail:
54004 return NULL;
54005 }
54006
54007
54008 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54009 PyObject *resultobj = 0;
54010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54011 wxSize result;
54012 void *argp1 = 0 ;
54013 int res1 = 0 ;
54014 PyObject *swig_obj[1] ;
54015
54016 if (!args) SWIG_fail;
54017 swig_obj[0] = args;
54018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54019 if (!SWIG_IsOK(res1)) {
54020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54021 }
54022 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54023 {
54024 PyThreadState* __tstate = wxPyBeginAllowThreads();
54025 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54026 wxPyEndAllowThreads(__tstate);
54027 if (PyErr_Occurred()) SWIG_fail;
54028 }
54029 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54030 return resultobj;
54031 fail:
54032 return NULL;
54033 }
54034
54035
54036 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54037 PyObject *resultobj = 0;
54038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54039 wxSize *arg2 = 0 ;
54040 void *argp1 = 0 ;
54041 int res1 = 0 ;
54042 wxSize temp2 ;
54043 PyObject * obj0 = 0 ;
54044 PyObject * obj1 = 0 ;
54045 char * kwnames[] = {
54046 (char *) "self",(char *) "sz", NULL
54047 };
54048
54049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54051 if (!SWIG_IsOK(res1)) {
54052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54053 }
54054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54055 {
54056 arg2 = &temp2;
54057 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54058 }
54059 {
54060 PyThreadState* __tstate = wxPyBeginAllowThreads();
54061 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54062 wxPyEndAllowThreads(__tstate);
54063 if (PyErr_Occurred()) SWIG_fail;
54064 }
54065 resultobj = SWIG_Py_Void();
54066 return resultobj;
54067 fail:
54068 return NULL;
54069 }
54070
54071
54072 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54073 PyObject *resultobj = 0;
54074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54075 wxWindow *arg2 = (wxWindow *) 0 ;
54076 wxGBPosition result;
54077 void *argp1 = 0 ;
54078 int res1 = 0 ;
54079 void *argp2 = 0 ;
54080 int res2 = 0 ;
54081
54082 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54084 if (!SWIG_IsOK(res1)) {
54085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54086 }
54087 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54088 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54089 if (!SWIG_IsOK(res2)) {
54090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54091 }
54092 arg2 = reinterpret_cast< wxWindow * >(argp2);
54093 {
54094 PyThreadState* __tstate = wxPyBeginAllowThreads();
54095 result = (arg1)->GetItemPosition(arg2);
54096 wxPyEndAllowThreads(__tstate);
54097 if (PyErr_Occurred()) SWIG_fail;
54098 }
54099 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54100 return resultobj;
54101 fail:
54102 return NULL;
54103 }
54104
54105
54106 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54107 PyObject *resultobj = 0;
54108 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54109 wxSizer *arg2 = (wxSizer *) 0 ;
54110 wxGBPosition result;
54111 void *argp1 = 0 ;
54112 int res1 = 0 ;
54113 void *argp2 = 0 ;
54114 int res2 = 0 ;
54115
54116 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54118 if (!SWIG_IsOK(res1)) {
54119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54120 }
54121 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54122 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54123 if (!SWIG_IsOK(res2)) {
54124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54125 }
54126 arg2 = reinterpret_cast< wxSizer * >(argp2);
54127 {
54128 PyThreadState* __tstate = wxPyBeginAllowThreads();
54129 result = (arg1)->GetItemPosition(arg2);
54130 wxPyEndAllowThreads(__tstate);
54131 if (PyErr_Occurred()) SWIG_fail;
54132 }
54133 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54134 return resultobj;
54135 fail:
54136 return NULL;
54137 }
54138
54139
54140 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54141 PyObject *resultobj = 0;
54142 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54143 size_t arg2 ;
54144 wxGBPosition result;
54145 void *argp1 = 0 ;
54146 int res1 = 0 ;
54147 size_t val2 ;
54148 int ecode2 = 0 ;
54149
54150 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54152 if (!SWIG_IsOK(res1)) {
54153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54154 }
54155 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54156 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54157 if (!SWIG_IsOK(ecode2)) {
54158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54159 }
54160 arg2 = static_cast< size_t >(val2);
54161 {
54162 PyThreadState* __tstate = wxPyBeginAllowThreads();
54163 result = (arg1)->GetItemPosition(arg2);
54164 wxPyEndAllowThreads(__tstate);
54165 if (PyErr_Occurred()) SWIG_fail;
54166 }
54167 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54168 return resultobj;
54169 fail:
54170 return NULL;
54171 }
54172
54173
54174 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54175 int argc;
54176 PyObject *argv[3];
54177
54178 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54179 --argc;
54180 if (argc == 2) {
54181 int _v = 0;
54182 {
54183 void *vptr = 0;
54184 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54185 _v = SWIG_CheckState(res);
54186 }
54187 if (!_v) goto check_1;
54188 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54189 }
54190 check_1:
54191
54192 if (argc == 2) {
54193 int _v = 0;
54194 {
54195 void *vptr = 0;
54196 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54197 _v = SWIG_CheckState(res);
54198 }
54199 if (!_v) goto check_2;
54200 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54201 }
54202 check_2:
54203
54204 if (argc == 2) {
54205 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54206 }
54207
54208 fail:
54209 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54210 return NULL;
54211 }
54212
54213
54214 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54215 PyObject *resultobj = 0;
54216 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54217 wxWindow *arg2 = (wxWindow *) 0 ;
54218 wxGBPosition *arg3 = 0 ;
54219 bool result;
54220 void *argp1 = 0 ;
54221 int res1 = 0 ;
54222 void *argp2 = 0 ;
54223 int res2 = 0 ;
54224 wxGBPosition temp3 ;
54225
54226 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54228 if (!SWIG_IsOK(res1)) {
54229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54230 }
54231 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54232 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54233 if (!SWIG_IsOK(res2)) {
54234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54235 }
54236 arg2 = reinterpret_cast< wxWindow * >(argp2);
54237 {
54238 arg3 = &temp3;
54239 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54240 }
54241 {
54242 PyThreadState* __tstate = wxPyBeginAllowThreads();
54243 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54244 wxPyEndAllowThreads(__tstate);
54245 if (PyErr_Occurred()) SWIG_fail;
54246 }
54247 {
54248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54249 }
54250 return resultobj;
54251 fail:
54252 return NULL;
54253 }
54254
54255
54256 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54257 PyObject *resultobj = 0;
54258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54259 wxSizer *arg2 = (wxSizer *) 0 ;
54260 wxGBPosition *arg3 = 0 ;
54261 bool result;
54262 void *argp1 = 0 ;
54263 int res1 = 0 ;
54264 void *argp2 = 0 ;
54265 int res2 = 0 ;
54266 wxGBPosition temp3 ;
54267
54268 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54270 if (!SWIG_IsOK(res1)) {
54271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54272 }
54273 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54274 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54275 if (!SWIG_IsOK(res2)) {
54276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54277 }
54278 arg2 = reinterpret_cast< wxSizer * >(argp2);
54279 {
54280 arg3 = &temp3;
54281 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54282 }
54283 {
54284 PyThreadState* __tstate = wxPyBeginAllowThreads();
54285 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54286 wxPyEndAllowThreads(__tstate);
54287 if (PyErr_Occurred()) SWIG_fail;
54288 }
54289 {
54290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54291 }
54292 return resultobj;
54293 fail:
54294 return NULL;
54295 }
54296
54297
54298 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54299 PyObject *resultobj = 0;
54300 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54301 size_t arg2 ;
54302 wxGBPosition *arg3 = 0 ;
54303 bool result;
54304 void *argp1 = 0 ;
54305 int res1 = 0 ;
54306 size_t val2 ;
54307 int ecode2 = 0 ;
54308 wxGBPosition temp3 ;
54309
54310 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54312 if (!SWIG_IsOK(res1)) {
54313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54314 }
54315 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54316 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54317 if (!SWIG_IsOK(ecode2)) {
54318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54319 }
54320 arg2 = static_cast< size_t >(val2);
54321 {
54322 arg3 = &temp3;
54323 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54324 }
54325 {
54326 PyThreadState* __tstate = wxPyBeginAllowThreads();
54327 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54328 wxPyEndAllowThreads(__tstate);
54329 if (PyErr_Occurred()) SWIG_fail;
54330 }
54331 {
54332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54333 }
54334 return resultobj;
54335 fail:
54336 return NULL;
54337 }
54338
54339
54340 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54341 int argc;
54342 PyObject *argv[4];
54343
54344 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54345 --argc;
54346 if (argc == 3) {
54347 int _v = 0;
54348 {
54349 void *vptr = 0;
54350 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54351 _v = SWIG_CheckState(res);
54352 }
54353 if (!_v) goto check_1;
54354 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54355 }
54356 check_1:
54357
54358 if (argc == 3) {
54359 int _v = 0;
54360 {
54361 void *vptr = 0;
54362 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54363 _v = SWIG_CheckState(res);
54364 }
54365 if (!_v) goto check_2;
54366 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54367 }
54368 check_2:
54369
54370 if (argc == 3) {
54371 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54372 }
54373
54374 fail:
54375 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54376 return NULL;
54377 }
54378
54379
54380 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54381 PyObject *resultobj = 0;
54382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54383 wxWindow *arg2 = (wxWindow *) 0 ;
54384 wxGBSpan result;
54385 void *argp1 = 0 ;
54386 int res1 = 0 ;
54387 void *argp2 = 0 ;
54388 int res2 = 0 ;
54389
54390 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54392 if (!SWIG_IsOK(res1)) {
54393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54394 }
54395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54396 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54397 if (!SWIG_IsOK(res2)) {
54398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54399 }
54400 arg2 = reinterpret_cast< wxWindow * >(argp2);
54401 {
54402 PyThreadState* __tstate = wxPyBeginAllowThreads();
54403 result = (arg1)->GetItemSpan(arg2);
54404 wxPyEndAllowThreads(__tstate);
54405 if (PyErr_Occurred()) SWIG_fail;
54406 }
54407 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54408 return resultobj;
54409 fail:
54410 return NULL;
54411 }
54412
54413
54414 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54415 PyObject *resultobj = 0;
54416 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54417 wxSizer *arg2 = (wxSizer *) 0 ;
54418 wxGBSpan result;
54419 void *argp1 = 0 ;
54420 int res1 = 0 ;
54421 void *argp2 = 0 ;
54422 int res2 = 0 ;
54423
54424 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54426 if (!SWIG_IsOK(res1)) {
54427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54428 }
54429 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54430 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54431 if (!SWIG_IsOK(res2)) {
54432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54433 }
54434 arg2 = reinterpret_cast< wxSizer * >(argp2);
54435 {
54436 PyThreadState* __tstate = wxPyBeginAllowThreads();
54437 result = (arg1)->GetItemSpan(arg2);
54438 wxPyEndAllowThreads(__tstate);
54439 if (PyErr_Occurred()) SWIG_fail;
54440 }
54441 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54442 return resultobj;
54443 fail:
54444 return NULL;
54445 }
54446
54447
54448 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54449 PyObject *resultobj = 0;
54450 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54451 size_t arg2 ;
54452 wxGBSpan result;
54453 void *argp1 = 0 ;
54454 int res1 = 0 ;
54455 size_t val2 ;
54456 int ecode2 = 0 ;
54457
54458 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54460 if (!SWIG_IsOK(res1)) {
54461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54462 }
54463 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54464 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54465 if (!SWIG_IsOK(ecode2)) {
54466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54467 }
54468 arg2 = static_cast< size_t >(val2);
54469 {
54470 PyThreadState* __tstate = wxPyBeginAllowThreads();
54471 result = (arg1)->GetItemSpan(arg2);
54472 wxPyEndAllowThreads(__tstate);
54473 if (PyErr_Occurred()) SWIG_fail;
54474 }
54475 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54476 return resultobj;
54477 fail:
54478 return NULL;
54479 }
54480
54481
54482 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54483 int argc;
54484 PyObject *argv[3];
54485
54486 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54487 --argc;
54488 if (argc == 2) {
54489 int _v = 0;
54490 {
54491 void *vptr = 0;
54492 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54493 _v = SWIG_CheckState(res);
54494 }
54495 if (!_v) goto check_1;
54496 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54497 }
54498 check_1:
54499
54500 if (argc == 2) {
54501 int _v = 0;
54502 {
54503 void *vptr = 0;
54504 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54505 _v = SWIG_CheckState(res);
54506 }
54507 if (!_v) goto check_2;
54508 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54509 }
54510 check_2:
54511
54512 if (argc == 2) {
54513 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54514 }
54515
54516 fail:
54517 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54518 return NULL;
54519 }
54520
54521
54522 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54523 PyObject *resultobj = 0;
54524 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54525 wxWindow *arg2 = (wxWindow *) 0 ;
54526 wxGBSpan *arg3 = 0 ;
54527 bool result;
54528 void *argp1 = 0 ;
54529 int res1 = 0 ;
54530 void *argp2 = 0 ;
54531 int res2 = 0 ;
54532 wxGBSpan temp3 ;
54533
54534 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54536 if (!SWIG_IsOK(res1)) {
54537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54538 }
54539 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54540 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54541 if (!SWIG_IsOK(res2)) {
54542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54543 }
54544 arg2 = reinterpret_cast< wxWindow * >(argp2);
54545 {
54546 arg3 = &temp3;
54547 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54548 }
54549 {
54550 PyThreadState* __tstate = wxPyBeginAllowThreads();
54551 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54552 wxPyEndAllowThreads(__tstate);
54553 if (PyErr_Occurred()) SWIG_fail;
54554 }
54555 {
54556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54557 }
54558 return resultobj;
54559 fail:
54560 return NULL;
54561 }
54562
54563
54564 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54565 PyObject *resultobj = 0;
54566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54567 wxSizer *arg2 = (wxSizer *) 0 ;
54568 wxGBSpan *arg3 = 0 ;
54569 bool result;
54570 void *argp1 = 0 ;
54571 int res1 = 0 ;
54572 void *argp2 = 0 ;
54573 int res2 = 0 ;
54574 wxGBSpan temp3 ;
54575
54576 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54578 if (!SWIG_IsOK(res1)) {
54579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54580 }
54581 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54583 if (!SWIG_IsOK(res2)) {
54584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54585 }
54586 arg2 = reinterpret_cast< wxSizer * >(argp2);
54587 {
54588 arg3 = &temp3;
54589 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54590 }
54591 {
54592 PyThreadState* __tstate = wxPyBeginAllowThreads();
54593 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54594 wxPyEndAllowThreads(__tstate);
54595 if (PyErr_Occurred()) SWIG_fail;
54596 }
54597 {
54598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54599 }
54600 return resultobj;
54601 fail:
54602 return NULL;
54603 }
54604
54605
54606 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54607 PyObject *resultobj = 0;
54608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54609 size_t arg2 ;
54610 wxGBSpan *arg3 = 0 ;
54611 bool result;
54612 void *argp1 = 0 ;
54613 int res1 = 0 ;
54614 size_t val2 ;
54615 int ecode2 = 0 ;
54616 wxGBSpan temp3 ;
54617
54618 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54620 if (!SWIG_IsOK(res1)) {
54621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54622 }
54623 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54624 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54625 if (!SWIG_IsOK(ecode2)) {
54626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54627 }
54628 arg2 = static_cast< size_t >(val2);
54629 {
54630 arg3 = &temp3;
54631 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54632 }
54633 {
54634 PyThreadState* __tstate = wxPyBeginAllowThreads();
54635 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54636 wxPyEndAllowThreads(__tstate);
54637 if (PyErr_Occurred()) SWIG_fail;
54638 }
54639 {
54640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54641 }
54642 return resultobj;
54643 fail:
54644 return NULL;
54645 }
54646
54647
54648 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54649 int argc;
54650 PyObject *argv[4];
54651
54652 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54653 --argc;
54654 if (argc == 3) {
54655 int _v = 0;
54656 {
54657 void *vptr = 0;
54658 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54659 _v = SWIG_CheckState(res);
54660 }
54661 if (!_v) goto check_1;
54662 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54663 }
54664 check_1:
54665
54666 if (argc == 3) {
54667 int _v = 0;
54668 {
54669 void *vptr = 0;
54670 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54671 _v = SWIG_CheckState(res);
54672 }
54673 if (!_v) goto check_2;
54674 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54675 }
54676 check_2:
54677
54678 if (argc == 3) {
54679 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54680 }
54681
54682 fail:
54683 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54684 return NULL;
54685 }
54686
54687
54688 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54689 PyObject *resultobj = 0;
54690 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54691 wxWindow *arg2 = (wxWindow *) 0 ;
54692 wxGBSizerItem *result = 0 ;
54693 void *argp1 = 0 ;
54694 int res1 = 0 ;
54695 void *argp2 = 0 ;
54696 int res2 = 0 ;
54697
54698 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54700 if (!SWIG_IsOK(res1)) {
54701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54702 }
54703 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54704 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54705 if (!SWIG_IsOK(res2)) {
54706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54707 }
54708 arg2 = reinterpret_cast< wxWindow * >(argp2);
54709 {
54710 PyThreadState* __tstate = wxPyBeginAllowThreads();
54711 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54712 wxPyEndAllowThreads(__tstate);
54713 if (PyErr_Occurred()) SWIG_fail;
54714 }
54715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54716 return resultobj;
54717 fail:
54718 return NULL;
54719 }
54720
54721
54722 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54723 PyObject *resultobj = 0;
54724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54725 wxSizer *arg2 = (wxSizer *) 0 ;
54726 wxGBSizerItem *result = 0 ;
54727 void *argp1 = 0 ;
54728 int res1 = 0 ;
54729 void *argp2 = 0 ;
54730 int res2 = 0 ;
54731
54732 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54734 if (!SWIG_IsOK(res1)) {
54735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54736 }
54737 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54738 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54739 if (!SWIG_IsOK(res2)) {
54740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54741 }
54742 arg2 = reinterpret_cast< wxSizer * >(argp2);
54743 {
54744 PyThreadState* __tstate = wxPyBeginAllowThreads();
54745 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54746 wxPyEndAllowThreads(__tstate);
54747 if (PyErr_Occurred()) SWIG_fail;
54748 }
54749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54750 return resultobj;
54751 fail:
54752 return NULL;
54753 }
54754
54755
54756 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54757 int argc;
54758 PyObject *argv[3];
54759
54760 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54761 --argc;
54762 if (argc == 2) {
54763 int _v = 0;
54764 {
54765 void *vptr = 0;
54766 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54767 _v = SWIG_CheckState(res);
54768 }
54769 if (!_v) goto check_1;
54770 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54771 }
54772 check_1:
54773
54774 if (argc == 2) {
54775 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54776 }
54777
54778 fail:
54779 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54780 return NULL;
54781 }
54782
54783
54784 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54785 PyObject *resultobj = 0;
54786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54787 wxGBPosition *arg2 = 0 ;
54788 wxGBSizerItem *result = 0 ;
54789 void *argp1 = 0 ;
54790 int res1 = 0 ;
54791 wxGBPosition temp2 ;
54792 PyObject * obj0 = 0 ;
54793 PyObject * obj1 = 0 ;
54794 char * kwnames[] = {
54795 (char *) "self",(char *) "pos", NULL
54796 };
54797
54798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54800 if (!SWIG_IsOK(res1)) {
54801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54802 }
54803 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54804 {
54805 arg2 = &temp2;
54806 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54807 }
54808 {
54809 PyThreadState* __tstate = wxPyBeginAllowThreads();
54810 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54811 wxPyEndAllowThreads(__tstate);
54812 if (PyErr_Occurred()) SWIG_fail;
54813 }
54814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54815 return resultobj;
54816 fail:
54817 return NULL;
54818 }
54819
54820
54821 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54822 PyObject *resultobj = 0;
54823 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54824 wxPoint *arg2 = 0 ;
54825 wxGBSizerItem *result = 0 ;
54826 void *argp1 = 0 ;
54827 int res1 = 0 ;
54828 wxPoint temp2 ;
54829 PyObject * obj0 = 0 ;
54830 PyObject * obj1 = 0 ;
54831 char * kwnames[] = {
54832 (char *) "self",(char *) "pt", NULL
54833 };
54834
54835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54837 if (!SWIG_IsOK(res1)) {
54838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54839 }
54840 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54841 {
54842 arg2 = &temp2;
54843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54844 }
54845 {
54846 PyThreadState* __tstate = wxPyBeginAllowThreads();
54847 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54848 wxPyEndAllowThreads(__tstate);
54849 if (PyErr_Occurred()) SWIG_fail;
54850 }
54851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54852 return resultobj;
54853 fail:
54854 return NULL;
54855 }
54856
54857
54858 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54859 PyObject *resultobj = 0;
54860 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54861 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54862 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54863 bool result;
54864 void *argp1 = 0 ;
54865 int res1 = 0 ;
54866 void *argp2 = 0 ;
54867 int res2 = 0 ;
54868 void *argp3 = 0 ;
54869 int res3 = 0 ;
54870 PyObject * obj0 = 0 ;
54871 PyObject * obj1 = 0 ;
54872 PyObject * obj2 = 0 ;
54873 char * kwnames[] = {
54874 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54875 };
54876
54877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54879 if (!SWIG_IsOK(res1)) {
54880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54881 }
54882 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54884 if (!SWIG_IsOK(res2)) {
54885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54886 }
54887 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54888 if (obj2) {
54889 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54890 if (!SWIG_IsOK(res3)) {
54891 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54892 }
54893 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54894 }
54895 {
54896 PyThreadState* __tstate = wxPyBeginAllowThreads();
54897 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54898 wxPyEndAllowThreads(__tstate);
54899 if (PyErr_Occurred()) SWIG_fail;
54900 }
54901 {
54902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54903 }
54904 return resultobj;
54905 fail:
54906 return NULL;
54907 }
54908
54909
54910 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54911 PyObject *resultobj = 0;
54912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54913 wxGBPosition *arg2 = 0 ;
54914 wxGBSpan *arg3 = 0 ;
54915 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54916 bool result;
54917 void *argp1 = 0 ;
54918 int res1 = 0 ;
54919 wxGBPosition temp2 ;
54920 wxGBSpan temp3 ;
54921 void *argp4 = 0 ;
54922 int res4 = 0 ;
54923 PyObject * obj0 = 0 ;
54924 PyObject * obj1 = 0 ;
54925 PyObject * obj2 = 0 ;
54926 PyObject * obj3 = 0 ;
54927 char * kwnames[] = {
54928 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54929 };
54930
54931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54933 if (!SWIG_IsOK(res1)) {
54934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54935 }
54936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54937 {
54938 arg2 = &temp2;
54939 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54940 }
54941 {
54942 arg3 = &temp3;
54943 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54944 }
54945 if (obj3) {
54946 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54947 if (!SWIG_IsOK(res4)) {
54948 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54949 }
54950 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54951 }
54952 {
54953 PyThreadState* __tstate = wxPyBeginAllowThreads();
54954 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54955 wxPyEndAllowThreads(__tstate);
54956 if (PyErr_Occurred()) SWIG_fail;
54957 }
54958 {
54959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54960 }
54961 return resultobj;
54962 fail:
54963 return NULL;
54964 }
54965
54966
54967 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54968 PyObject *obj;
54969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54970 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54971 return SWIG_Py_Void();
54972 }
54973
54974 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54975 return SWIG_Python_InitShadowInstance(args);
54976 }
54977
54978 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54979 PyObject *resultobj = 0;
54980 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54981 wxRelationship arg2 ;
54982 wxWindow *arg3 = (wxWindow *) 0 ;
54983 wxEdge arg4 ;
54984 int arg5 = (int) 0 ;
54985 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
54986 void *argp1 = 0 ;
54987 int res1 = 0 ;
54988 int val2 ;
54989 int ecode2 = 0 ;
54990 void *argp3 = 0 ;
54991 int res3 = 0 ;
54992 int val4 ;
54993 int ecode4 = 0 ;
54994 int val5 ;
54995 int ecode5 = 0 ;
54996 int val6 ;
54997 int ecode6 = 0 ;
54998 PyObject * obj0 = 0 ;
54999 PyObject * obj1 = 0 ;
55000 PyObject * obj2 = 0 ;
55001 PyObject * obj3 = 0 ;
55002 PyObject * obj4 = 0 ;
55003 PyObject * obj5 = 0 ;
55004 char * kwnames[] = {
55005 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55006 };
55007
55008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55010 if (!SWIG_IsOK(res1)) {
55011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55012 }
55013 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55014 ecode2 = SWIG_AsVal_int(obj1, &val2);
55015 if (!SWIG_IsOK(ecode2)) {
55016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55017 }
55018 arg2 = static_cast< wxRelationship >(val2);
55019 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55020 if (!SWIG_IsOK(res3)) {
55021 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55022 }
55023 arg3 = reinterpret_cast< wxWindow * >(argp3);
55024 ecode4 = SWIG_AsVal_int(obj3, &val4);
55025 if (!SWIG_IsOK(ecode4)) {
55026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55027 }
55028 arg4 = static_cast< wxEdge >(val4);
55029 if (obj4) {
55030 ecode5 = SWIG_AsVal_int(obj4, &val5);
55031 if (!SWIG_IsOK(ecode5)) {
55032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55033 }
55034 arg5 = static_cast< int >(val5);
55035 }
55036 if (obj5) {
55037 ecode6 = SWIG_AsVal_int(obj5, &val6);
55038 if (!SWIG_IsOK(ecode6)) {
55039 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55040 }
55041 arg6 = static_cast< int >(val6);
55042 }
55043 {
55044 PyThreadState* __tstate = wxPyBeginAllowThreads();
55045 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55046 wxPyEndAllowThreads(__tstate);
55047 if (PyErr_Occurred()) SWIG_fail;
55048 }
55049 resultobj = SWIG_Py_Void();
55050 return resultobj;
55051 fail:
55052 return NULL;
55053 }
55054
55055
55056 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55057 PyObject *resultobj = 0;
55058 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55059 wxWindow *arg2 = (wxWindow *) 0 ;
55060 int arg3 = (int) 0 ;
55061 void *argp1 = 0 ;
55062 int res1 = 0 ;
55063 void *argp2 = 0 ;
55064 int res2 = 0 ;
55065 int val3 ;
55066 int ecode3 = 0 ;
55067 PyObject * obj0 = 0 ;
55068 PyObject * obj1 = 0 ;
55069 PyObject * obj2 = 0 ;
55070 char * kwnames[] = {
55071 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55072 };
55073
55074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55076 if (!SWIG_IsOK(res1)) {
55077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55078 }
55079 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55081 if (!SWIG_IsOK(res2)) {
55082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55083 }
55084 arg2 = reinterpret_cast< wxWindow * >(argp2);
55085 if (obj2) {
55086 ecode3 = SWIG_AsVal_int(obj2, &val3);
55087 if (!SWIG_IsOK(ecode3)) {
55088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55089 }
55090 arg3 = static_cast< int >(val3);
55091 }
55092 {
55093 PyThreadState* __tstate = wxPyBeginAllowThreads();
55094 (arg1)->LeftOf(arg2,arg3);
55095 wxPyEndAllowThreads(__tstate);
55096 if (PyErr_Occurred()) SWIG_fail;
55097 }
55098 resultobj = SWIG_Py_Void();
55099 return resultobj;
55100 fail:
55101 return NULL;
55102 }
55103
55104
55105 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55106 PyObject *resultobj = 0;
55107 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55108 wxWindow *arg2 = (wxWindow *) 0 ;
55109 int arg3 = (int) 0 ;
55110 void *argp1 = 0 ;
55111 int res1 = 0 ;
55112 void *argp2 = 0 ;
55113 int res2 = 0 ;
55114 int val3 ;
55115 int ecode3 = 0 ;
55116 PyObject * obj0 = 0 ;
55117 PyObject * obj1 = 0 ;
55118 PyObject * obj2 = 0 ;
55119 char * kwnames[] = {
55120 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55121 };
55122
55123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55125 if (!SWIG_IsOK(res1)) {
55126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55127 }
55128 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55130 if (!SWIG_IsOK(res2)) {
55131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55132 }
55133 arg2 = reinterpret_cast< wxWindow * >(argp2);
55134 if (obj2) {
55135 ecode3 = SWIG_AsVal_int(obj2, &val3);
55136 if (!SWIG_IsOK(ecode3)) {
55137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55138 }
55139 arg3 = static_cast< int >(val3);
55140 }
55141 {
55142 PyThreadState* __tstate = wxPyBeginAllowThreads();
55143 (arg1)->RightOf(arg2,arg3);
55144 wxPyEndAllowThreads(__tstate);
55145 if (PyErr_Occurred()) SWIG_fail;
55146 }
55147 resultobj = SWIG_Py_Void();
55148 return resultobj;
55149 fail:
55150 return NULL;
55151 }
55152
55153
55154 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55155 PyObject *resultobj = 0;
55156 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55157 wxWindow *arg2 = (wxWindow *) 0 ;
55158 int arg3 = (int) 0 ;
55159 void *argp1 = 0 ;
55160 int res1 = 0 ;
55161 void *argp2 = 0 ;
55162 int res2 = 0 ;
55163 int val3 ;
55164 int ecode3 = 0 ;
55165 PyObject * obj0 = 0 ;
55166 PyObject * obj1 = 0 ;
55167 PyObject * obj2 = 0 ;
55168 char * kwnames[] = {
55169 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55170 };
55171
55172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55174 if (!SWIG_IsOK(res1)) {
55175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55176 }
55177 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55179 if (!SWIG_IsOK(res2)) {
55180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55181 }
55182 arg2 = reinterpret_cast< wxWindow * >(argp2);
55183 if (obj2) {
55184 ecode3 = SWIG_AsVal_int(obj2, &val3);
55185 if (!SWIG_IsOK(ecode3)) {
55186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55187 }
55188 arg3 = static_cast< int >(val3);
55189 }
55190 {
55191 PyThreadState* __tstate = wxPyBeginAllowThreads();
55192 (arg1)->Above(arg2,arg3);
55193 wxPyEndAllowThreads(__tstate);
55194 if (PyErr_Occurred()) SWIG_fail;
55195 }
55196 resultobj = SWIG_Py_Void();
55197 return resultobj;
55198 fail:
55199 return NULL;
55200 }
55201
55202
55203 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55204 PyObject *resultobj = 0;
55205 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55206 wxWindow *arg2 = (wxWindow *) 0 ;
55207 int arg3 = (int) 0 ;
55208 void *argp1 = 0 ;
55209 int res1 = 0 ;
55210 void *argp2 = 0 ;
55211 int res2 = 0 ;
55212 int val3 ;
55213 int ecode3 = 0 ;
55214 PyObject * obj0 = 0 ;
55215 PyObject * obj1 = 0 ;
55216 PyObject * obj2 = 0 ;
55217 char * kwnames[] = {
55218 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55219 };
55220
55221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55223 if (!SWIG_IsOK(res1)) {
55224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55225 }
55226 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55228 if (!SWIG_IsOK(res2)) {
55229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55230 }
55231 arg2 = reinterpret_cast< wxWindow * >(argp2);
55232 if (obj2) {
55233 ecode3 = SWIG_AsVal_int(obj2, &val3);
55234 if (!SWIG_IsOK(ecode3)) {
55235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55236 }
55237 arg3 = static_cast< int >(val3);
55238 }
55239 {
55240 PyThreadState* __tstate = wxPyBeginAllowThreads();
55241 (arg1)->Below(arg2,arg3);
55242 wxPyEndAllowThreads(__tstate);
55243 if (PyErr_Occurred()) SWIG_fail;
55244 }
55245 resultobj = SWIG_Py_Void();
55246 return resultobj;
55247 fail:
55248 return NULL;
55249 }
55250
55251
55252 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55253 PyObject *resultobj = 0;
55254 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55255 wxWindow *arg2 = (wxWindow *) 0 ;
55256 wxEdge arg3 ;
55257 int arg4 = (int) 0 ;
55258 void *argp1 = 0 ;
55259 int res1 = 0 ;
55260 void *argp2 = 0 ;
55261 int res2 = 0 ;
55262 int val3 ;
55263 int ecode3 = 0 ;
55264 int val4 ;
55265 int ecode4 = 0 ;
55266 PyObject * obj0 = 0 ;
55267 PyObject * obj1 = 0 ;
55268 PyObject * obj2 = 0 ;
55269 PyObject * obj3 = 0 ;
55270 char * kwnames[] = {
55271 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55272 };
55273
55274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55276 if (!SWIG_IsOK(res1)) {
55277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55278 }
55279 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55281 if (!SWIG_IsOK(res2)) {
55282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55283 }
55284 arg2 = reinterpret_cast< wxWindow * >(argp2);
55285 ecode3 = SWIG_AsVal_int(obj2, &val3);
55286 if (!SWIG_IsOK(ecode3)) {
55287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55288 }
55289 arg3 = static_cast< wxEdge >(val3);
55290 if (obj3) {
55291 ecode4 = SWIG_AsVal_int(obj3, &val4);
55292 if (!SWIG_IsOK(ecode4)) {
55293 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55294 }
55295 arg4 = static_cast< int >(val4);
55296 }
55297 {
55298 PyThreadState* __tstate = wxPyBeginAllowThreads();
55299 (arg1)->SameAs(arg2,arg3,arg4);
55300 wxPyEndAllowThreads(__tstate);
55301 if (PyErr_Occurred()) SWIG_fail;
55302 }
55303 resultobj = SWIG_Py_Void();
55304 return resultobj;
55305 fail:
55306 return NULL;
55307 }
55308
55309
55310 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55311 PyObject *resultobj = 0;
55312 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55313 wxWindow *arg2 = (wxWindow *) 0 ;
55314 wxEdge arg3 ;
55315 int arg4 ;
55316 void *argp1 = 0 ;
55317 int res1 = 0 ;
55318 void *argp2 = 0 ;
55319 int res2 = 0 ;
55320 int val3 ;
55321 int ecode3 = 0 ;
55322 int val4 ;
55323 int ecode4 = 0 ;
55324 PyObject * obj0 = 0 ;
55325 PyObject * obj1 = 0 ;
55326 PyObject * obj2 = 0 ;
55327 PyObject * obj3 = 0 ;
55328 char * kwnames[] = {
55329 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55330 };
55331
55332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55334 if (!SWIG_IsOK(res1)) {
55335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55336 }
55337 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55339 if (!SWIG_IsOK(res2)) {
55340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55341 }
55342 arg2 = reinterpret_cast< wxWindow * >(argp2);
55343 ecode3 = SWIG_AsVal_int(obj2, &val3);
55344 if (!SWIG_IsOK(ecode3)) {
55345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55346 }
55347 arg3 = static_cast< wxEdge >(val3);
55348 ecode4 = SWIG_AsVal_int(obj3, &val4);
55349 if (!SWIG_IsOK(ecode4)) {
55350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55351 }
55352 arg4 = static_cast< int >(val4);
55353 {
55354 PyThreadState* __tstate = wxPyBeginAllowThreads();
55355 (arg1)->PercentOf(arg2,arg3,arg4);
55356 wxPyEndAllowThreads(__tstate);
55357 if (PyErr_Occurred()) SWIG_fail;
55358 }
55359 resultobj = SWIG_Py_Void();
55360 return resultobj;
55361 fail:
55362 return NULL;
55363 }
55364
55365
55366 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55367 PyObject *resultobj = 0;
55368 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55369 int arg2 ;
55370 void *argp1 = 0 ;
55371 int res1 = 0 ;
55372 int val2 ;
55373 int ecode2 = 0 ;
55374 PyObject * obj0 = 0 ;
55375 PyObject * obj1 = 0 ;
55376 char * kwnames[] = {
55377 (char *) "self",(char *) "val", NULL
55378 };
55379
55380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55382 if (!SWIG_IsOK(res1)) {
55383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55384 }
55385 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55386 ecode2 = SWIG_AsVal_int(obj1, &val2);
55387 if (!SWIG_IsOK(ecode2)) {
55388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55389 }
55390 arg2 = static_cast< int >(val2);
55391 {
55392 PyThreadState* __tstate = wxPyBeginAllowThreads();
55393 (arg1)->Absolute(arg2);
55394 wxPyEndAllowThreads(__tstate);
55395 if (PyErr_Occurred()) SWIG_fail;
55396 }
55397 resultobj = SWIG_Py_Void();
55398 return resultobj;
55399 fail:
55400 return NULL;
55401 }
55402
55403
55404 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55405 PyObject *resultobj = 0;
55406 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55407 void *argp1 = 0 ;
55408 int res1 = 0 ;
55409 PyObject *swig_obj[1] ;
55410
55411 if (!args) SWIG_fail;
55412 swig_obj[0] = args;
55413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55414 if (!SWIG_IsOK(res1)) {
55415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55416 }
55417 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55418 {
55419 PyThreadState* __tstate = wxPyBeginAllowThreads();
55420 (arg1)->Unconstrained();
55421 wxPyEndAllowThreads(__tstate);
55422 if (PyErr_Occurred()) SWIG_fail;
55423 }
55424 resultobj = SWIG_Py_Void();
55425 return resultobj;
55426 fail:
55427 return NULL;
55428 }
55429
55430
55431 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55432 PyObject *resultobj = 0;
55433 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55434 void *argp1 = 0 ;
55435 int res1 = 0 ;
55436 PyObject *swig_obj[1] ;
55437
55438 if (!args) SWIG_fail;
55439 swig_obj[0] = args;
55440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55441 if (!SWIG_IsOK(res1)) {
55442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55443 }
55444 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55445 {
55446 PyThreadState* __tstate = wxPyBeginAllowThreads();
55447 (arg1)->AsIs();
55448 wxPyEndAllowThreads(__tstate);
55449 if (PyErr_Occurred()) SWIG_fail;
55450 }
55451 resultobj = SWIG_Py_Void();
55452 return resultobj;
55453 fail:
55454 return NULL;
55455 }
55456
55457
55458 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55459 PyObject *resultobj = 0;
55460 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55461 wxWindow *result = 0 ;
55462 void *argp1 = 0 ;
55463 int res1 = 0 ;
55464 PyObject *swig_obj[1] ;
55465
55466 if (!args) SWIG_fail;
55467 swig_obj[0] = args;
55468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55469 if (!SWIG_IsOK(res1)) {
55470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55471 }
55472 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55473 {
55474 PyThreadState* __tstate = wxPyBeginAllowThreads();
55475 result = (wxWindow *)(arg1)->GetOtherWindow();
55476 wxPyEndAllowThreads(__tstate);
55477 if (PyErr_Occurred()) SWIG_fail;
55478 }
55479 {
55480 resultobj = wxPyMake_wxObject(result, 0);
55481 }
55482 return resultobj;
55483 fail:
55484 return NULL;
55485 }
55486
55487
55488 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55489 PyObject *resultobj = 0;
55490 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55491 wxEdge result;
55492 void *argp1 = 0 ;
55493 int res1 = 0 ;
55494 PyObject *swig_obj[1] ;
55495
55496 if (!args) SWIG_fail;
55497 swig_obj[0] = args;
55498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55499 if (!SWIG_IsOK(res1)) {
55500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55501 }
55502 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55503 {
55504 PyThreadState* __tstate = wxPyBeginAllowThreads();
55505 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55506 wxPyEndAllowThreads(__tstate);
55507 if (PyErr_Occurred()) SWIG_fail;
55508 }
55509 resultobj = SWIG_From_int(static_cast< int >(result));
55510 return resultobj;
55511 fail:
55512 return NULL;
55513 }
55514
55515
55516 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55517 PyObject *resultobj = 0;
55518 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55519 wxEdge arg2 ;
55520 void *argp1 = 0 ;
55521 int res1 = 0 ;
55522 int val2 ;
55523 int ecode2 = 0 ;
55524 PyObject * obj0 = 0 ;
55525 PyObject * obj1 = 0 ;
55526 char * kwnames[] = {
55527 (char *) "self",(char *) "which", NULL
55528 };
55529
55530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55532 if (!SWIG_IsOK(res1)) {
55533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55534 }
55535 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55536 ecode2 = SWIG_AsVal_int(obj1, &val2);
55537 if (!SWIG_IsOK(ecode2)) {
55538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55539 }
55540 arg2 = static_cast< wxEdge >(val2);
55541 {
55542 PyThreadState* __tstate = wxPyBeginAllowThreads();
55543 (arg1)->SetEdge(arg2);
55544 wxPyEndAllowThreads(__tstate);
55545 if (PyErr_Occurred()) SWIG_fail;
55546 }
55547 resultobj = SWIG_Py_Void();
55548 return resultobj;
55549 fail:
55550 return NULL;
55551 }
55552
55553
55554 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55555 PyObject *resultobj = 0;
55556 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55557 int arg2 ;
55558 void *argp1 = 0 ;
55559 int res1 = 0 ;
55560 int val2 ;
55561 int ecode2 = 0 ;
55562 PyObject * obj0 = 0 ;
55563 PyObject * obj1 = 0 ;
55564 char * kwnames[] = {
55565 (char *) "self",(char *) "v", NULL
55566 };
55567
55568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55570 if (!SWIG_IsOK(res1)) {
55571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55572 }
55573 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55574 ecode2 = SWIG_AsVal_int(obj1, &val2);
55575 if (!SWIG_IsOK(ecode2)) {
55576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55577 }
55578 arg2 = static_cast< int >(val2);
55579 {
55580 PyThreadState* __tstate = wxPyBeginAllowThreads();
55581 (arg1)->SetValue(arg2);
55582 wxPyEndAllowThreads(__tstate);
55583 if (PyErr_Occurred()) SWIG_fail;
55584 }
55585 resultobj = SWIG_Py_Void();
55586 return resultobj;
55587 fail:
55588 return NULL;
55589 }
55590
55591
55592 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55593 PyObject *resultobj = 0;
55594 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55595 int result;
55596 void *argp1 = 0 ;
55597 int res1 = 0 ;
55598 PyObject *swig_obj[1] ;
55599
55600 if (!args) SWIG_fail;
55601 swig_obj[0] = args;
55602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55603 if (!SWIG_IsOK(res1)) {
55604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55605 }
55606 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55607 {
55608 PyThreadState* __tstate = wxPyBeginAllowThreads();
55609 result = (int)(arg1)->GetMargin();
55610 wxPyEndAllowThreads(__tstate);
55611 if (PyErr_Occurred()) SWIG_fail;
55612 }
55613 resultobj = SWIG_From_int(static_cast< int >(result));
55614 return resultobj;
55615 fail:
55616 return NULL;
55617 }
55618
55619
55620 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55621 PyObject *resultobj = 0;
55622 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55623 int arg2 ;
55624 void *argp1 = 0 ;
55625 int res1 = 0 ;
55626 int val2 ;
55627 int ecode2 = 0 ;
55628 PyObject * obj0 = 0 ;
55629 PyObject * obj1 = 0 ;
55630 char * kwnames[] = {
55631 (char *) "self",(char *) "m", NULL
55632 };
55633
55634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55636 if (!SWIG_IsOK(res1)) {
55637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55638 }
55639 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55640 ecode2 = SWIG_AsVal_int(obj1, &val2);
55641 if (!SWIG_IsOK(ecode2)) {
55642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55643 }
55644 arg2 = static_cast< int >(val2);
55645 {
55646 PyThreadState* __tstate = wxPyBeginAllowThreads();
55647 (arg1)->SetMargin(arg2);
55648 wxPyEndAllowThreads(__tstate);
55649 if (PyErr_Occurred()) SWIG_fail;
55650 }
55651 resultobj = SWIG_Py_Void();
55652 return resultobj;
55653 fail:
55654 return NULL;
55655 }
55656
55657
55658 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55659 PyObject *resultobj = 0;
55660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55661 int result;
55662 void *argp1 = 0 ;
55663 int res1 = 0 ;
55664 PyObject *swig_obj[1] ;
55665
55666 if (!args) SWIG_fail;
55667 swig_obj[0] = args;
55668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55669 if (!SWIG_IsOK(res1)) {
55670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55671 }
55672 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55673 {
55674 PyThreadState* __tstate = wxPyBeginAllowThreads();
55675 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55676 wxPyEndAllowThreads(__tstate);
55677 if (PyErr_Occurred()) SWIG_fail;
55678 }
55679 resultobj = SWIG_From_int(static_cast< int >(result));
55680 return resultobj;
55681 fail:
55682 return NULL;
55683 }
55684
55685
55686 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55687 PyObject *resultobj = 0;
55688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55689 int result;
55690 void *argp1 = 0 ;
55691 int res1 = 0 ;
55692 PyObject *swig_obj[1] ;
55693
55694 if (!args) SWIG_fail;
55695 swig_obj[0] = args;
55696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55697 if (!SWIG_IsOK(res1)) {
55698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55699 }
55700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55701 {
55702 PyThreadState* __tstate = wxPyBeginAllowThreads();
55703 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55704 wxPyEndAllowThreads(__tstate);
55705 if (PyErr_Occurred()) SWIG_fail;
55706 }
55707 resultobj = SWIG_From_int(static_cast< int >(result));
55708 return resultobj;
55709 fail:
55710 return NULL;
55711 }
55712
55713
55714 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55715 PyObject *resultobj = 0;
55716 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55717 int result;
55718 void *argp1 = 0 ;
55719 int res1 = 0 ;
55720 PyObject *swig_obj[1] ;
55721
55722 if (!args) SWIG_fail;
55723 swig_obj[0] = args;
55724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55725 if (!SWIG_IsOK(res1)) {
55726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55727 }
55728 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55729 {
55730 PyThreadState* __tstate = wxPyBeginAllowThreads();
55731 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55732 wxPyEndAllowThreads(__tstate);
55733 if (PyErr_Occurred()) SWIG_fail;
55734 }
55735 resultobj = SWIG_From_int(static_cast< int >(result));
55736 return resultobj;
55737 fail:
55738 return NULL;
55739 }
55740
55741
55742 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55743 PyObject *resultobj = 0;
55744 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55745 bool result;
55746 void *argp1 = 0 ;
55747 int res1 = 0 ;
55748 PyObject *swig_obj[1] ;
55749
55750 if (!args) SWIG_fail;
55751 swig_obj[0] = args;
55752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55753 if (!SWIG_IsOK(res1)) {
55754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55755 }
55756 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55757 {
55758 PyThreadState* __tstate = wxPyBeginAllowThreads();
55759 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55760 wxPyEndAllowThreads(__tstate);
55761 if (PyErr_Occurred()) SWIG_fail;
55762 }
55763 {
55764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55765 }
55766 return resultobj;
55767 fail:
55768 return NULL;
55769 }
55770
55771
55772 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55773 PyObject *resultobj = 0;
55774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55775 bool arg2 ;
55776 void *argp1 = 0 ;
55777 int res1 = 0 ;
55778 bool val2 ;
55779 int ecode2 = 0 ;
55780 PyObject * obj0 = 0 ;
55781 PyObject * obj1 = 0 ;
55782 char * kwnames[] = {
55783 (char *) "self",(char *) "d", NULL
55784 };
55785
55786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55788 if (!SWIG_IsOK(res1)) {
55789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55790 }
55791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55793 if (!SWIG_IsOK(ecode2)) {
55794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55795 }
55796 arg2 = static_cast< bool >(val2);
55797 {
55798 PyThreadState* __tstate = wxPyBeginAllowThreads();
55799 (arg1)->SetDone(arg2);
55800 wxPyEndAllowThreads(__tstate);
55801 if (PyErr_Occurred()) SWIG_fail;
55802 }
55803 resultobj = SWIG_Py_Void();
55804 return resultobj;
55805 fail:
55806 return NULL;
55807 }
55808
55809
55810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55811 PyObject *resultobj = 0;
55812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55813 wxRelationship result;
55814 void *argp1 = 0 ;
55815 int res1 = 0 ;
55816 PyObject *swig_obj[1] ;
55817
55818 if (!args) SWIG_fail;
55819 swig_obj[0] = args;
55820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55821 if (!SWIG_IsOK(res1)) {
55822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55823 }
55824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55825 {
55826 PyThreadState* __tstate = wxPyBeginAllowThreads();
55827 result = (wxRelationship)(arg1)->GetRelationship();
55828 wxPyEndAllowThreads(__tstate);
55829 if (PyErr_Occurred()) SWIG_fail;
55830 }
55831 resultobj = SWIG_From_int(static_cast< int >(result));
55832 return resultobj;
55833 fail:
55834 return NULL;
55835 }
55836
55837
55838 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55839 PyObject *resultobj = 0;
55840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55841 wxRelationship arg2 ;
55842 void *argp1 = 0 ;
55843 int res1 = 0 ;
55844 int val2 ;
55845 int ecode2 = 0 ;
55846 PyObject * obj0 = 0 ;
55847 PyObject * obj1 = 0 ;
55848 char * kwnames[] = {
55849 (char *) "self",(char *) "r", NULL
55850 };
55851
55852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55854 if (!SWIG_IsOK(res1)) {
55855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55856 }
55857 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55858 ecode2 = SWIG_AsVal_int(obj1, &val2);
55859 if (!SWIG_IsOK(ecode2)) {
55860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55861 }
55862 arg2 = static_cast< wxRelationship >(val2);
55863 {
55864 PyThreadState* __tstate = wxPyBeginAllowThreads();
55865 (arg1)->SetRelationship(arg2);
55866 wxPyEndAllowThreads(__tstate);
55867 if (PyErr_Occurred()) SWIG_fail;
55868 }
55869 resultobj = SWIG_Py_Void();
55870 return resultobj;
55871 fail:
55872 return NULL;
55873 }
55874
55875
55876 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55877 PyObject *resultobj = 0;
55878 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55879 wxWindow *arg2 = (wxWindow *) 0 ;
55880 bool result;
55881 void *argp1 = 0 ;
55882 int res1 = 0 ;
55883 void *argp2 = 0 ;
55884 int res2 = 0 ;
55885 PyObject * obj0 = 0 ;
55886 PyObject * obj1 = 0 ;
55887 char * kwnames[] = {
55888 (char *) "self",(char *) "otherW", NULL
55889 };
55890
55891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55893 if (!SWIG_IsOK(res1)) {
55894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55895 }
55896 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55897 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55898 if (!SWIG_IsOK(res2)) {
55899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55900 }
55901 arg2 = reinterpret_cast< wxWindow * >(argp2);
55902 {
55903 PyThreadState* __tstate = wxPyBeginAllowThreads();
55904 result = (bool)(arg1)->ResetIfWin(arg2);
55905 wxPyEndAllowThreads(__tstate);
55906 if (PyErr_Occurred()) SWIG_fail;
55907 }
55908 {
55909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55910 }
55911 return resultobj;
55912 fail:
55913 return NULL;
55914 }
55915
55916
55917 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55918 PyObject *resultobj = 0;
55919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55920 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55921 wxWindow *arg3 = (wxWindow *) 0 ;
55922 bool result;
55923 void *argp1 = 0 ;
55924 int res1 = 0 ;
55925 void *argp2 = 0 ;
55926 int res2 = 0 ;
55927 void *argp3 = 0 ;
55928 int res3 = 0 ;
55929 PyObject * obj0 = 0 ;
55930 PyObject * obj1 = 0 ;
55931 PyObject * obj2 = 0 ;
55932 char * kwnames[] = {
55933 (char *) "self",(char *) "constraints",(char *) "win", NULL
55934 };
55935
55936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55938 if (!SWIG_IsOK(res1)) {
55939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55940 }
55941 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55943 if (!SWIG_IsOK(res2)) {
55944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55945 }
55946 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55947 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55948 if (!SWIG_IsOK(res3)) {
55949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55950 }
55951 arg3 = reinterpret_cast< wxWindow * >(argp3);
55952 {
55953 PyThreadState* __tstate = wxPyBeginAllowThreads();
55954 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55955 wxPyEndAllowThreads(__tstate);
55956 if (PyErr_Occurred()) SWIG_fail;
55957 }
55958 {
55959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55960 }
55961 return resultobj;
55962 fail:
55963 return NULL;
55964 }
55965
55966
55967 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55968 PyObject *resultobj = 0;
55969 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55970 wxEdge arg2 ;
55971 wxWindow *arg3 = (wxWindow *) 0 ;
55972 wxWindow *arg4 = (wxWindow *) 0 ;
55973 int result;
55974 void *argp1 = 0 ;
55975 int res1 = 0 ;
55976 int val2 ;
55977 int ecode2 = 0 ;
55978 void *argp3 = 0 ;
55979 int res3 = 0 ;
55980 void *argp4 = 0 ;
55981 int res4 = 0 ;
55982 PyObject * obj0 = 0 ;
55983 PyObject * obj1 = 0 ;
55984 PyObject * obj2 = 0 ;
55985 PyObject * obj3 = 0 ;
55986 char * kwnames[] = {
55987 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
55988 };
55989
55990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55992 if (!SWIG_IsOK(res1)) {
55993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55994 }
55995 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55996 ecode2 = SWIG_AsVal_int(obj1, &val2);
55997 if (!SWIG_IsOK(ecode2)) {
55998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55999 }
56000 arg2 = static_cast< wxEdge >(val2);
56001 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56002 if (!SWIG_IsOK(res3)) {
56003 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56004 }
56005 arg3 = reinterpret_cast< wxWindow * >(argp3);
56006 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56007 if (!SWIG_IsOK(res4)) {
56008 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56009 }
56010 arg4 = reinterpret_cast< wxWindow * >(argp4);
56011 {
56012 PyThreadState* __tstate = wxPyBeginAllowThreads();
56013 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56014 wxPyEndAllowThreads(__tstate);
56015 if (PyErr_Occurred()) SWIG_fail;
56016 }
56017 resultobj = SWIG_From_int(static_cast< int >(result));
56018 return resultobj;
56019 fail:
56020 return NULL;
56021 }
56022
56023
56024 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56025 PyObject *obj;
56026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56027 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56028 return SWIG_Py_Void();
56029 }
56030
56031 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56032 PyObject *resultobj = 0;
56033 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56034 wxIndividualLayoutConstraint *result = 0 ;
56035 void *argp1 = 0 ;
56036 int res1 = 0 ;
56037 PyObject *swig_obj[1] ;
56038
56039 if (!args) SWIG_fail;
56040 swig_obj[0] = args;
56041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56042 if (!SWIG_IsOK(res1)) {
56043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56044 }
56045 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56046 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56048 return resultobj;
56049 fail:
56050 return NULL;
56051 }
56052
56053
56054 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56055 PyObject *resultobj = 0;
56056 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56057 wxIndividualLayoutConstraint *result = 0 ;
56058 void *argp1 = 0 ;
56059 int res1 = 0 ;
56060 PyObject *swig_obj[1] ;
56061
56062 if (!args) SWIG_fail;
56063 swig_obj[0] = args;
56064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56065 if (!SWIG_IsOK(res1)) {
56066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56067 }
56068 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56069 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56071 return resultobj;
56072 fail:
56073 return NULL;
56074 }
56075
56076
56077 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56078 PyObject *resultobj = 0;
56079 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56080 wxIndividualLayoutConstraint *result = 0 ;
56081 void *argp1 = 0 ;
56082 int res1 = 0 ;
56083 PyObject *swig_obj[1] ;
56084
56085 if (!args) SWIG_fail;
56086 swig_obj[0] = args;
56087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56088 if (!SWIG_IsOK(res1)) {
56089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56090 }
56091 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56092 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56094 return resultobj;
56095 fail:
56096 return NULL;
56097 }
56098
56099
56100 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56101 PyObject *resultobj = 0;
56102 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56103 wxIndividualLayoutConstraint *result = 0 ;
56104 void *argp1 = 0 ;
56105 int res1 = 0 ;
56106 PyObject *swig_obj[1] ;
56107
56108 if (!args) SWIG_fail;
56109 swig_obj[0] = args;
56110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56111 if (!SWIG_IsOK(res1)) {
56112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56113 }
56114 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56115 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56117 return resultobj;
56118 fail:
56119 return NULL;
56120 }
56121
56122
56123 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56124 PyObject *resultobj = 0;
56125 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56126 wxIndividualLayoutConstraint *result = 0 ;
56127 void *argp1 = 0 ;
56128 int res1 = 0 ;
56129 PyObject *swig_obj[1] ;
56130
56131 if (!args) SWIG_fail;
56132 swig_obj[0] = args;
56133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56134 if (!SWIG_IsOK(res1)) {
56135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56136 }
56137 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56138 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56140 return resultobj;
56141 fail:
56142 return NULL;
56143 }
56144
56145
56146 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56147 PyObject *resultobj = 0;
56148 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56149 wxIndividualLayoutConstraint *result = 0 ;
56150 void *argp1 = 0 ;
56151 int res1 = 0 ;
56152 PyObject *swig_obj[1] ;
56153
56154 if (!args) SWIG_fail;
56155 swig_obj[0] = args;
56156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56157 if (!SWIG_IsOK(res1)) {
56158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56159 }
56160 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56161 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56163 return resultobj;
56164 fail:
56165 return NULL;
56166 }
56167
56168
56169 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56170 PyObject *resultobj = 0;
56171 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56172 wxIndividualLayoutConstraint *result = 0 ;
56173 void *argp1 = 0 ;
56174 int res1 = 0 ;
56175 PyObject *swig_obj[1] ;
56176
56177 if (!args) SWIG_fail;
56178 swig_obj[0] = args;
56179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56180 if (!SWIG_IsOK(res1)) {
56181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56182 }
56183 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56184 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56186 return resultobj;
56187 fail:
56188 return NULL;
56189 }
56190
56191
56192 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56193 PyObject *resultobj = 0;
56194 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56195 wxIndividualLayoutConstraint *result = 0 ;
56196 void *argp1 = 0 ;
56197 int res1 = 0 ;
56198 PyObject *swig_obj[1] ;
56199
56200 if (!args) SWIG_fail;
56201 swig_obj[0] = args;
56202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56203 if (!SWIG_IsOK(res1)) {
56204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56205 }
56206 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56207 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56209 return resultobj;
56210 fail:
56211 return NULL;
56212 }
56213
56214
56215 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56216 PyObject *resultobj = 0;
56217 wxLayoutConstraints *result = 0 ;
56218
56219 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56220 {
56221 PyThreadState* __tstate = wxPyBeginAllowThreads();
56222 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56223 wxPyEndAllowThreads(__tstate);
56224 if (PyErr_Occurred()) SWIG_fail;
56225 }
56226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56227 return resultobj;
56228 fail:
56229 return NULL;
56230 }
56231
56232
56233 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56234 PyObject *resultobj = 0;
56235 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56236 void *argp1 = 0 ;
56237 int res1 = 0 ;
56238 PyObject *swig_obj[1] ;
56239
56240 if (!args) SWIG_fail;
56241 swig_obj[0] = args;
56242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56243 if (!SWIG_IsOK(res1)) {
56244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56245 }
56246 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56247 {
56248 PyThreadState* __tstate = wxPyBeginAllowThreads();
56249 delete arg1;
56250
56251 wxPyEndAllowThreads(__tstate);
56252 if (PyErr_Occurred()) SWIG_fail;
56253 }
56254 resultobj = SWIG_Py_Void();
56255 return resultobj;
56256 fail:
56257 return NULL;
56258 }
56259
56260
56261 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56262 PyObject *resultobj = 0;
56263 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56264 wxWindow *arg2 = (wxWindow *) 0 ;
56265 int *arg3 = (int *) 0 ;
56266 bool result;
56267 void *argp1 = 0 ;
56268 int res1 = 0 ;
56269 void *argp2 = 0 ;
56270 int res2 = 0 ;
56271 int temp3 ;
56272 int res3 = SWIG_TMPOBJ ;
56273 PyObject * obj0 = 0 ;
56274 PyObject * obj1 = 0 ;
56275 char * kwnames[] = {
56276 (char *) "self",(char *) "win", NULL
56277 };
56278
56279 arg3 = &temp3;
56280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56282 if (!SWIG_IsOK(res1)) {
56283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56284 }
56285 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56287 if (!SWIG_IsOK(res2)) {
56288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56289 }
56290 arg2 = reinterpret_cast< wxWindow * >(argp2);
56291 {
56292 PyThreadState* __tstate = wxPyBeginAllowThreads();
56293 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56294 wxPyEndAllowThreads(__tstate);
56295 if (PyErr_Occurred()) SWIG_fail;
56296 }
56297 {
56298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56299 }
56300 if (SWIG_IsTmpObj(res3)) {
56301 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56302 } else {
56303 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56304 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56305 }
56306 return resultobj;
56307 fail:
56308 return NULL;
56309 }
56310
56311
56312 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56313 PyObject *resultobj = 0;
56314 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56315 bool result;
56316 void *argp1 = 0 ;
56317 int res1 = 0 ;
56318 PyObject *swig_obj[1] ;
56319
56320 if (!args) SWIG_fail;
56321 swig_obj[0] = args;
56322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56323 if (!SWIG_IsOK(res1)) {
56324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56325 }
56326 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56327 {
56328 PyThreadState* __tstate = wxPyBeginAllowThreads();
56329 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56330 wxPyEndAllowThreads(__tstate);
56331 if (PyErr_Occurred()) SWIG_fail;
56332 }
56333 {
56334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56335 }
56336 return resultobj;
56337 fail:
56338 return NULL;
56339 }
56340
56341
56342 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56343 PyObject *obj;
56344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56345 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56346 return SWIG_Py_Void();
56347 }
56348
56349 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56350 return SWIG_Python_InitShadowInstance(args);
56351 }
56352
56353 static PyMethodDef SwigMethods[] = {
56354 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56355 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56356 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56357 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56358 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56359 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56360 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56361 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56362 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56363 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56364 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56365 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56366 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56367 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56368 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56369 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56370 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56371 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56372 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56373 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56374 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56375 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56376 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56377 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56378 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56379 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56380 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56381 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56382 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56383 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56384 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56385 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56386 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56387 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56388 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56389 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56390 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56391 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56392 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56393 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56394 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56395 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56396 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56397 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56398 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56399 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56400 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56401 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56402 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56403 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56404 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56405 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56407 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56409 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56410 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56411 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56412 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56413 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56414 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56415 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56416 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56417 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56418 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56419 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56420 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56422 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56423 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56424 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56425 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56426 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56427 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56428 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56429 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56430 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56432 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56433 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56434 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56435 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56437 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56439 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56441 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56442 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56443 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56444 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56452 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56464 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56465 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56466 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56467 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56468 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56469 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56470 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56471 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56473 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56474 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56475 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56480 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56481 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56482 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56483 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56484 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56491 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56498 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56499 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56500 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56501 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56503 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56504 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56505 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56507 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56508 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56509 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56510 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56513 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56516 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56519 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56522 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56525 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56528 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56531 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56534 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56540 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56542 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56551 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56554 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56555 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56556 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56557 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56558 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56559 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56560 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56561 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56563 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56564 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56565 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56567 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56568 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56569 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56570 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56575 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56576 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56577 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56578 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56579 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56580 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56583 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56584 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56585 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56587 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56588 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56590 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56591 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56592 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56593 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56594 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56595 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56596 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56597 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56598 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56599 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56600 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56601 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56606 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56612 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56613 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56614 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56615 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56617 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56620 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56623 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56626 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56627 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56628 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56631 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56632 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56633 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56637 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56638 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56639 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56643 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56648 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56649 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56650 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56651 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56652 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56653 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56654 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56661 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56662 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56664 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56665 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56666 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56672 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56673 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56675 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56676 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56677 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56678 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56679 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56680 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56681 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56682 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56684 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56685 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56686 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56687 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56688 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56689 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56690 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56691 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56693 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56702 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56719 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56720 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56735 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56736 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56737 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56738 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56741 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56743 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56745 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56747 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56749 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56752 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56753 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56754 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56755 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56757 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56774 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56775 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56781 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56782 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56784 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56785 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56786 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56787 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56788 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56789 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56790 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56791 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56792 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56793 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56794 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56795 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56796 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56797 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56798 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56799 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56800 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56801 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56802 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56803 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56804 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56805 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56806 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56807 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56808 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56809 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56810 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56811 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56812 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56813 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56814 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56815 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56816 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56817 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56818 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56819 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56821 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56822 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56823 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56824 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56827 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56831 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56835 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56836 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56837 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56838 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56840 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56841 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56843 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56845 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56847 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56849 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56850 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56851 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56853 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56854 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56856 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56857 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56858 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56860 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56861 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56862 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56864 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56866 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56867 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56868 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56869 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56870 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56872 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56873 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56875 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56876 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56877 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56879 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56880 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56881 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56882 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56883 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56885 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56886 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56887 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56889 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56890 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56891 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56892 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56893 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56894 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56895 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56896 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56897 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56898 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56899 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56900 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56901 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56904 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56905 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56906 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56907 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56908 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56909 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56910 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56911 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56912 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56913 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56914 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56915 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56916 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56917 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56918 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56919 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56920 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56921 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56922 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56923 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56924 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56925 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56926 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56927 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56928 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56930 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56931 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56932 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56933 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56934 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56935 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56936 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56937 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56938 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56939 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56940 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56941 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56942 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56943 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56944 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56945 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56946 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56947 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56948 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56949 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56950 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56951 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56952 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56953 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56954 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56955 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56956 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56957 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56958 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56959 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56960 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56961 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56962 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56963 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56964 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56966 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56967 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56968 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56969 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56971 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56972 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56973 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56974 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56975 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56976 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56977 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56978 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56979 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56981 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56982 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56983 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56984 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
56985 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
56986 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
56987 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
56988 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
56989 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
56990 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
56991 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
56992 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
56993 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
56994 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
56995 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
56996 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
56997 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
56998 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
56999 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57000 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57001 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57002 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57003 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57004 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57005 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57006 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57007 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57008 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57009 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57010 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57011 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57012 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57013 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57014 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57015 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57016 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57017 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57018 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57019 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57021 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57022 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57023 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57024 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57025 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57026 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57027 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57028 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57029 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57030 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57031 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57032 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57033 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57034 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57035 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57036 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57037 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57038 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57039 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57040 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57041 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57042 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57043 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57044 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57045 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57046 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57047 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57048 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57049 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57051 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57052 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57053 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57054 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57055 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57056 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57057 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57058 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57059 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57061 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57062 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57063 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57064 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57065 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57066 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57067 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57068 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57069 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57070 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57071 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57072 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57073 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57074 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57075 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57076 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57077 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57078 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57079 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57080 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57081 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57082 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57083 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57085 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57086 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57087 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57088 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57089 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57090 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57091 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57092 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57094 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57095 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57097 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57098 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57100 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57101 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57102 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57105 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57106 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57107 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57109 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57110 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57111 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57112 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57113 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57114 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57115 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57116 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57117 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57120 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57122 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57125 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57128 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57129 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57130 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57131 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57133 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57135 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57136 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57138 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57139 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57141 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57142 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57143 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57145 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57146 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57147 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57149 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57151 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57152 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57153 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57155 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57156 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57157 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57158 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57159 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57160 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57161 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57162 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57163 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57165 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57167 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57168 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57169 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57170 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57171 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57172 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57173 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57174 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57175 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57176 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57177 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57179 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57180 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57181 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57182 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57183 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57184 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57186 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57188 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57190 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57191 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57193 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57194 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57195 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57196 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57197 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57198 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57199 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57200 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57201 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57203 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57205 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57206 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57207 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57209 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57211 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57212 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57213 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57214 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57215 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57216 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57217 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57218 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57222 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57224 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57225 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57226 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57227 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57228 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57229 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57230 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57231 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57232 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57233 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57235 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57236 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57237 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57238 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57239 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57240 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57241 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57242 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57243 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57244 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57245 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57246 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57248 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57249 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57251 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57252 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57253 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57255 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57258 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57259 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57260 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57261 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57262 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57263 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57264 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57265 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57266 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57267 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57268 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57269 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57270 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57272 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57273 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57274 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57275 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57276 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57277 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57278 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57279 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57280 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57281 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57283 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57286 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57287 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57288 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57290 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57292 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57294 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57296 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57297 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57298 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57300 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57306 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57307 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57310 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57311 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57315 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57316 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57317 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57318 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57319 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57320 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57321 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57322 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57323 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57324 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57325 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57326 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57327 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57328 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57329 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57330 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57331 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57332 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57334 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57335 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57340 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57341 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57342 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57344 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57345 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57346 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57347 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57350 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57351 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57352 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57354 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57355 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57356 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57357 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57358 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57359 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57360 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57361 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57363 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57365 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57368 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57369 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57370 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57371 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57372 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57373 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57377 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57378 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57379 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57380 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57383 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57387 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57393 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57394 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57395 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57396 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57397 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57399 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57409 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57410 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57411 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57412 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57415 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57416 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57417 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57418 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57419 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57421 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57422 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57423 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57427 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57433 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57434 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57435 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57436 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57438 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57439 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57441 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57444 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57446 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57447 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57448 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57449 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57451 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57457 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57461 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57462 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57464 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57474 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57475 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57476 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57477 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57481 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57484 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57486 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57489 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57490 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57491 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57492 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57495 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57497 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57498 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57499 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57500 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57502 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57503 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57508 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57509 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57510 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57512 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57513 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57514 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57516 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57518 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57519 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57520 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57522 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57523 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57526 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57534 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57541 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57549 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57552 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57553 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57566 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57568 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57570 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57571 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57573 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57575 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57576 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57578 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57579 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57580 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57584 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57603 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57604 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57606 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57607 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57609 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57610 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57611 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57613 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57614 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57617 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57618 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57620 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57621 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57623 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57626 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57627 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57629 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57631 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57633 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57634 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57636 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57637 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57640 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57642 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57644 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57646 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57649 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57651 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57652 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57653 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57655 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57656 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57657 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57659 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57661 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57662 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57665 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57666 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57670 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57674 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57675 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57677 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57681 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57683 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57685 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57686 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57687 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57688 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57692 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57693 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57694 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57695 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57697 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57698 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57703 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57704 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57705 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57706 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57707 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57709 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57711 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57713 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57714 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57716 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57718 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57721 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57722 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57723 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57725 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57726 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57727 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57740 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57746 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57747 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57748 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57749 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57750 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57751 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57757 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57758 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57762 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57763 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57765 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57766 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57768 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57770 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57771 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57773 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57774 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57775 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57781 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57782 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57783 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57784 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57785 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57786 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57793 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57795 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57796 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57797 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57798 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57799 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57800 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57802 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57806 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57807 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57808 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57809 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57810 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57811 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57812 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57814 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57815 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57816 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57822 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57823 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57824 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57826 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57827 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57828 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57834 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57835 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57836 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57837 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57838 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57842 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57843 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57848 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57849 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57851 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57852 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57857 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57859 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57860 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57861 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57862 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57863 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57868 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57869 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57878 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57879 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57880 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57881 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57884 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57886 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57887 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57888 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57889 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57891 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57896 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57897 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57898 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57899 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57900 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57901 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57902 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57903 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57904 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57905 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57906 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57908 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57909 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57910 { NULL, NULL, 0, NULL }
57911 };
57912
57913
57914 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57915
57916 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57917 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57918 }
57919 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57920 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57921 }
57922 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57923 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57924 }
57925 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57926 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57927 }
57928 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57929 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57930 }
57931 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57932 return (void *)((wxSizer *) ((wxGridSizer *) x));
57933 }
57934 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57935 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57936 }
57937 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57938 return (void *)((wxSizer *) ((wxPySizer *) x));
57939 }
57940 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57941 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57942 }
57943 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57944 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57945 }
57946 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57947 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57948 }
57949 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57950 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57951 }
57952 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57953 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57954 }
57955 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57956 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57957 }
57958 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57959 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57960 }
57961 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57962 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57963 }
57964 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57965 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57966 }
57967 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57968 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57969 }
57970 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57971 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57972 }
57973 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57974 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57975 }
57976 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57977 return (void *)((wxEvent *) ((wxPyEvent *) x));
57978 }
57979 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57980 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57981 }
57982 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57983 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
57984 }
57985 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
57986 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
57987 }
57988 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
57989 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
57990 }
57991 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
57992 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
57993 }
57994 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
57995 return (void *)((wxEvent *) ((wxActivateEvent *) x));
57996 }
57997 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
57998 return (void *)((wxEvent *) ((wxSizeEvent *) x));
57999 }
58000 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58001 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58002 }
58003 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58004 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58005 }
58006 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58007 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58008 }
58009 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58010 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58011 }
58012 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58013 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58014 }
58015 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58016 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58017 }
58018 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58019 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58020 }
58021 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58022 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58023 }
58024 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58025 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58026 }
58027 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58028 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58029 }
58030 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58031 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58032 }
58033 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58034 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58035 }
58036 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58038 }
58039 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) ((wxShowEvent *) x));
58041 }
58042 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58044 }
58045 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58047 }
58048 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58050 }
58051 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58053 }
58054 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58056 }
58057 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58059 }
58060 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58061 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58062 }
58063 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58064 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58065 }
58066 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58067 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58068 }
58069 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58070 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58071 }
58072 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58073 return (void *)((wxControl *) ((wxControlWithItems *) x));
58074 }
58075 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58076 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58077 }
58078 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58079 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58080 }
58081 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58082 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58083 }
58084 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58085 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58086 }
58087 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58088 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58089 }
58090 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58091 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58092 }
58093 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58094 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58095 }
58096 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58097 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58098 }
58099 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58100 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58101 }
58102 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58103 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58104 }
58105 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58106 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58107 }
58108 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58109 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58110 }
58111 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58112 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58113 }
58114 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58115 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58116 }
58117 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58118 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58119 }
58120 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58121 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58122 }
58123 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58124 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58125 }
58126 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58127 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58128 }
58129 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58130 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58131 }
58132 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58133 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58134 }
58135 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58136 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58137 }
58138 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58139 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58140 }
58141 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58142 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58143 }
58144 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58145 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58146 }
58147 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58148 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58149 }
58150 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58151 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58152 }
58153 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58154 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58155 }
58156 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58157 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58158 }
58159 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58160 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58161 }
58162 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58163 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58164 }
58165 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58166 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58167 }
58168 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58169 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58170 }
58171 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58172 return (void *)((wxObject *) ((wxSizerItem *) x));
58173 }
58174 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58175 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58176 }
58177 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58178 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58179 }
58180 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58181 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58182 }
58183 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58184 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58185 }
58186 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58187 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58188 }
58189 static void *_p_wxSizerTo_p_wxObject(void *x) {
58190 return (void *)((wxObject *) ((wxSizer *) x));
58191 }
58192 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58193 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58194 }
58195 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58196 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58197 }
58198 static void *_p_wxEventTo_p_wxObject(void *x) {
58199 return (void *)((wxObject *) ((wxEvent *) x));
58200 }
58201 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58202 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58203 }
58204 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58205 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58206 }
58207 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58208 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58209 }
58210 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58211 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58212 }
58213 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58214 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58215 }
58216 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58217 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58218 }
58219 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58220 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58221 }
58222 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58223 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58224 }
58225 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58226 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58227 }
58228 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58229 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58230 }
58231 static void *_p_wxControlTo_p_wxObject(void *x) {
58232 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58233 }
58234 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58235 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58236 }
58237 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58238 return (void *)((wxObject *) ((wxFSFile *) x));
58239 }
58240 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58241 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58242 }
58243 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58244 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58245 }
58246 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58247 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58248 }
58249 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58250 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58251 }
58252 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58253 return (void *)((wxObject *) ((wxMenuItem *) x));
58254 }
58255 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58256 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58257 }
58258 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58260 }
58261 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58263 }
58264 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58266 }
58267 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58269 }
58270 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58272 }
58273 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58275 }
58276 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58278 }
58279 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58281 }
58282 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58284 }
58285 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58287 }
58288 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58290 }
58291 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58293 }
58294 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58296 }
58297 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58299 }
58300 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58302 }
58303 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58305 }
58306 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58308 }
58309 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58311 }
58312 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) ((wxImageHandler *) x));
58314 }
58315 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58317 }
58318 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58320 }
58321 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58323 }
58324 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) ((wxEvtHandler *) x));
58326 }
58327 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58329 }
58330 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58332 }
58333 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58335 }
58336 static void *_p_wxImageTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) ((wxImage *) x));
58338 }
58339 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58341 }
58342 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58344 }
58345 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58347 }
58348 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58350 }
58351 static void *_p_wxWindowTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58353 }
58354 static void *_p_wxMenuTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58356 }
58357 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58359 }
58360 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) ((wxFileSystem *) x));
58362 }
58363 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58365 }
58366 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58368 }
58369 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58371 }
58372 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58374 }
58375 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58377 }
58378 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58380 }
58381 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58383 }
58384 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58386 }
58387 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58389 }
58390 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58392 }
58393 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58395 }
58396 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58398 }
58399 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58401 }
58402 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58404 }
58405 static void *_p_wxControlTo_p_wxWindow(void *x) {
58406 return (void *)((wxWindow *) ((wxControl *) x));
58407 }
58408 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58409 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58410 }
58411 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58412 return (void *)((wxWindow *) ((wxMenuBar *) x));
58413 }
58414 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58415 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58416 }
58417 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58418 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58419 }
58420 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58421 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58422 }
58423 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58424 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58425 }
58426 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58427 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58428 }
58429 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58430 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58431 }
58432 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58433 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58434 }
58435 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58436 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58437 }
58438 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58439 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58440 }
58441 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58442 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58443 }
58444 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58445 return (void *)((wxValidator *) ((wxPyValidator *) x));
58446 }
58447 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58448 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58449 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};
58450 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58451 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58452 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58453 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58454 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58455 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58456 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58457 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58458 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58459 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58460 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58461 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58462 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58463 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58464 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58465 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58466 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58582
58583 static swig_type_info *swig_type_initial[] = {
58584 &_swigt__p_buffer,
58585 &_swigt__p_char,
58586 &_swigt__p_form_ops_t,
58587 &_swigt__p_int,
58588 &_swigt__p_long,
58589 &_swigt__p_unsigned_char,
58590 &_swigt__p_unsigned_int,
58591 &_swigt__p_unsigned_long,
58592 &_swigt__p_wxANIHandler,
58593 &_swigt__p_wxAcceleratorEntry,
58594 &_swigt__p_wxAcceleratorTable,
58595 &_swigt__p_wxActivateEvent,
58596 &_swigt__p_wxAppTraits,
58597 &_swigt__p_wxArrayString,
58598 &_swigt__p_wxBMPHandler,
58599 &_swigt__p_wxBitmap,
58600 &_swigt__p_wxBoxSizer,
58601 &_swigt__p_wxButton,
58602 &_swigt__p_wxCURHandler,
58603 &_swigt__p_wxCaret,
58604 &_swigt__p_wxChildFocusEvent,
58605 &_swigt__p_wxClipboardTextEvent,
58606 &_swigt__p_wxCloseEvent,
58607 &_swigt__p_wxColour,
58608 &_swigt__p_wxCommandEvent,
58609 &_swigt__p_wxContextMenuEvent,
58610 &_swigt__p_wxControl,
58611 &_swigt__p_wxControlWithItems,
58612 &_swigt__p_wxCursor,
58613 &_swigt__p_wxDC,
58614 &_swigt__p_wxDateEvent,
58615 &_swigt__p_wxDateTime,
58616 &_swigt__p_wxDisplayChangedEvent,
58617 &_swigt__p_wxDouble,
58618 &_swigt__p_wxDropFilesEvent,
58619 &_swigt__p_wxDuplexMode,
58620 &_swigt__p_wxEraseEvent,
58621 &_swigt__p_wxEvent,
58622 &_swigt__p_wxEventLoop,
58623 &_swigt__p_wxEventLoopActivator,
58624 &_swigt__p_wxEvtHandler,
58625 &_swigt__p_wxFSFile,
58626 &_swigt__p_wxFileSystem,
58627 &_swigt__p_wxFileSystemHandler,
58628 &_swigt__p_wxFlexGridSizer,
58629 &_swigt__p_wxFocusEvent,
58630 &_swigt__p_wxFont,
58631 &_swigt__p_wxFrame,
58632 &_swigt__p_wxGBPosition,
58633 &_swigt__p_wxGBSizerItem,
58634 &_swigt__p_wxGBSpan,
58635 &_swigt__p_wxGIFHandler,
58636 &_swigt__p_wxGridBagSizer,
58637 &_swigt__p_wxGridSizer,
58638 &_swigt__p_wxHelpEvent__Origin,
58639 &_swigt__p_wxICOHandler,
58640 &_swigt__p_wxIconizeEvent,
58641 &_swigt__p_wxIdleEvent,
58642 &_swigt__p_wxImage,
58643 &_swigt__p_wxImageHandler,
58644 &_swigt__p_wxImageHistogram,
58645 &_swigt__p_wxImage_HSVValue,
58646 &_swigt__p_wxImage_RGBValue,
58647 &_swigt__p_wxIndividualLayoutConstraint,
58648 &_swigt__p_wxInitDialogEvent,
58649 &_swigt__p_wxInputStream,
58650 &_swigt__p_wxInternetFSHandler,
58651 &_swigt__p_wxItemContainer,
58652 &_swigt__p_wxJPEGHandler,
58653 &_swigt__p_wxKeyEvent,
58654 &_swigt__p_wxLayoutConstraints,
58655 &_swigt__p_wxMaximizeEvent,
58656 &_swigt__p_wxMemoryFSHandler,
58657 &_swigt__p_wxMenu,
58658 &_swigt__p_wxMenuBar,
58659 &_swigt__p_wxMenuBarBase,
58660 &_swigt__p_wxMenuEvent,
58661 &_swigt__p_wxMenuItem,
58662 &_swigt__p_wxMouseCaptureChangedEvent,
58663 &_swigt__p_wxMouseCaptureLostEvent,
58664 &_swigt__p_wxMouseEvent,
58665 &_swigt__p_wxMoveEvent,
58666 &_swigt__p_wxNavigationKeyEvent,
58667 &_swigt__p_wxNcPaintEvent,
58668 &_swigt__p_wxNotifyEvent,
58669 &_swigt__p_wxObject,
58670 &_swigt__p_wxOutputStream,
58671 &_swigt__p_wxPCXHandler,
58672 &_swigt__p_wxPNGHandler,
58673 &_swigt__p_wxPNMHandler,
58674 &_swigt__p_wxPaintEvent,
58675 &_swigt__p_wxPaletteChangedEvent,
58676 &_swigt__p_wxPaperSize,
58677 &_swigt__p_wxPoint,
58678 &_swigt__p_wxPoint2D,
58679 &_swigt__p_wxPropagateOnce,
58680 &_swigt__p_wxPropagationDisabler,
58681 &_swigt__p_wxPyApp,
58682 &_swigt__p_wxPyCommandEvent,
58683 &_swigt__p_wxPyDropTarget,
58684 &_swigt__p_wxPyEvent,
58685 &_swigt__p_wxPyFileSystemHandler,
58686 &_swigt__p_wxPyImageHandler,
58687 &_swigt__p_wxPyInputStream,
58688 &_swigt__p_wxPySizer,
58689 &_swigt__p_wxPyValidator,
58690 &_swigt__p_wxQuantize,
58691 &_swigt__p_wxQueryNewPaletteEvent,
58692 &_swigt__p_wxRealPoint,
58693 &_swigt__p_wxRect,
58694 &_swigt__p_wxRect2D,
58695 &_swigt__p_wxRegion,
58696 &_swigt__p_wxScrollEvent,
58697 &_swigt__p_wxScrollWinEvent,
58698 &_swigt__p_wxSetCursorEvent,
58699 &_swigt__p_wxShowEvent,
58700 &_swigt__p_wxSize,
58701 &_swigt__p_wxSizeEvent,
58702 &_swigt__p_wxSizer,
58703 &_swigt__p_wxSizerItem,
58704 &_swigt__p_wxStaticBox,
58705 &_swigt__p_wxStaticBoxSizer,
58706 &_swigt__p_wxStdDialogButtonSizer,
58707 &_swigt__p_wxSysColourChangedEvent,
58708 &_swigt__p_wxTGAHandler,
58709 &_swigt__p_wxTIFFHandler,
58710 &_swigt__p_wxToolTip,
58711 &_swigt__p_wxUpdateUIEvent,
58712 &_swigt__p_wxValidator,
58713 &_swigt__p_wxVisualAttributes,
58714 &_swigt__p_wxWindow,
58715 &_swigt__p_wxWindowCreateEvent,
58716 &_swigt__p_wxWindowDestroyEvent,
58717 &_swigt__p_wxXPMHandler,
58718 &_swigt__p_wxZipFSHandler,
58719 };
58720
58721 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58722 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58723 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58724 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58725 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58726 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58727 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58728 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58729 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58730 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58731 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58732 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58733 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58734 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58735 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}};
58736 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58737 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}};
58738 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58739 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}};
58740 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58741 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58745 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}};
58746 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58747 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}};
58748 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58749 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58750 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58751 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58752 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58753 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58754 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58755 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58756 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58758 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}};
58759 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58761 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}};
58762 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58763 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58764 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}};
58765 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}};
58766 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58767 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58768 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58774 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}};
58775 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58776 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}};
58777 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58778 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58780 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}};
58781 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58788 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}};
58789 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58793 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58794 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58806 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}};
58807 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58839 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}};
58840 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}};
58841 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58849 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}};
58850 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58851 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}};
58852 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58856
58857 static swig_cast_info *swig_cast_initial[] = {
58858 _swigc__p_buffer,
58859 _swigc__p_char,
58860 _swigc__p_form_ops_t,
58861 _swigc__p_int,
58862 _swigc__p_long,
58863 _swigc__p_unsigned_char,
58864 _swigc__p_unsigned_int,
58865 _swigc__p_unsigned_long,
58866 _swigc__p_wxANIHandler,
58867 _swigc__p_wxAcceleratorEntry,
58868 _swigc__p_wxAcceleratorTable,
58869 _swigc__p_wxActivateEvent,
58870 _swigc__p_wxAppTraits,
58871 _swigc__p_wxArrayString,
58872 _swigc__p_wxBMPHandler,
58873 _swigc__p_wxBitmap,
58874 _swigc__p_wxBoxSizer,
58875 _swigc__p_wxButton,
58876 _swigc__p_wxCURHandler,
58877 _swigc__p_wxCaret,
58878 _swigc__p_wxChildFocusEvent,
58879 _swigc__p_wxClipboardTextEvent,
58880 _swigc__p_wxCloseEvent,
58881 _swigc__p_wxColour,
58882 _swigc__p_wxCommandEvent,
58883 _swigc__p_wxContextMenuEvent,
58884 _swigc__p_wxControl,
58885 _swigc__p_wxControlWithItems,
58886 _swigc__p_wxCursor,
58887 _swigc__p_wxDC,
58888 _swigc__p_wxDateEvent,
58889 _swigc__p_wxDateTime,
58890 _swigc__p_wxDisplayChangedEvent,
58891 _swigc__p_wxDouble,
58892 _swigc__p_wxDropFilesEvent,
58893 _swigc__p_wxDuplexMode,
58894 _swigc__p_wxEraseEvent,
58895 _swigc__p_wxEvent,
58896 _swigc__p_wxEventLoop,
58897 _swigc__p_wxEventLoopActivator,
58898 _swigc__p_wxEvtHandler,
58899 _swigc__p_wxFSFile,
58900 _swigc__p_wxFileSystem,
58901 _swigc__p_wxFileSystemHandler,
58902 _swigc__p_wxFlexGridSizer,
58903 _swigc__p_wxFocusEvent,
58904 _swigc__p_wxFont,
58905 _swigc__p_wxFrame,
58906 _swigc__p_wxGBPosition,
58907 _swigc__p_wxGBSizerItem,
58908 _swigc__p_wxGBSpan,
58909 _swigc__p_wxGIFHandler,
58910 _swigc__p_wxGridBagSizer,
58911 _swigc__p_wxGridSizer,
58912 _swigc__p_wxHelpEvent__Origin,
58913 _swigc__p_wxICOHandler,
58914 _swigc__p_wxIconizeEvent,
58915 _swigc__p_wxIdleEvent,
58916 _swigc__p_wxImage,
58917 _swigc__p_wxImageHandler,
58918 _swigc__p_wxImageHistogram,
58919 _swigc__p_wxImage_HSVValue,
58920 _swigc__p_wxImage_RGBValue,
58921 _swigc__p_wxIndividualLayoutConstraint,
58922 _swigc__p_wxInitDialogEvent,
58923 _swigc__p_wxInputStream,
58924 _swigc__p_wxInternetFSHandler,
58925 _swigc__p_wxItemContainer,
58926 _swigc__p_wxJPEGHandler,
58927 _swigc__p_wxKeyEvent,
58928 _swigc__p_wxLayoutConstraints,
58929 _swigc__p_wxMaximizeEvent,
58930 _swigc__p_wxMemoryFSHandler,
58931 _swigc__p_wxMenu,
58932 _swigc__p_wxMenuBar,
58933 _swigc__p_wxMenuBarBase,
58934 _swigc__p_wxMenuEvent,
58935 _swigc__p_wxMenuItem,
58936 _swigc__p_wxMouseCaptureChangedEvent,
58937 _swigc__p_wxMouseCaptureLostEvent,
58938 _swigc__p_wxMouseEvent,
58939 _swigc__p_wxMoveEvent,
58940 _swigc__p_wxNavigationKeyEvent,
58941 _swigc__p_wxNcPaintEvent,
58942 _swigc__p_wxNotifyEvent,
58943 _swigc__p_wxObject,
58944 _swigc__p_wxOutputStream,
58945 _swigc__p_wxPCXHandler,
58946 _swigc__p_wxPNGHandler,
58947 _swigc__p_wxPNMHandler,
58948 _swigc__p_wxPaintEvent,
58949 _swigc__p_wxPaletteChangedEvent,
58950 _swigc__p_wxPaperSize,
58951 _swigc__p_wxPoint,
58952 _swigc__p_wxPoint2D,
58953 _swigc__p_wxPropagateOnce,
58954 _swigc__p_wxPropagationDisabler,
58955 _swigc__p_wxPyApp,
58956 _swigc__p_wxPyCommandEvent,
58957 _swigc__p_wxPyDropTarget,
58958 _swigc__p_wxPyEvent,
58959 _swigc__p_wxPyFileSystemHandler,
58960 _swigc__p_wxPyImageHandler,
58961 _swigc__p_wxPyInputStream,
58962 _swigc__p_wxPySizer,
58963 _swigc__p_wxPyValidator,
58964 _swigc__p_wxQuantize,
58965 _swigc__p_wxQueryNewPaletteEvent,
58966 _swigc__p_wxRealPoint,
58967 _swigc__p_wxRect,
58968 _swigc__p_wxRect2D,
58969 _swigc__p_wxRegion,
58970 _swigc__p_wxScrollEvent,
58971 _swigc__p_wxScrollWinEvent,
58972 _swigc__p_wxSetCursorEvent,
58973 _swigc__p_wxShowEvent,
58974 _swigc__p_wxSize,
58975 _swigc__p_wxSizeEvent,
58976 _swigc__p_wxSizer,
58977 _swigc__p_wxSizerItem,
58978 _swigc__p_wxStaticBox,
58979 _swigc__p_wxStaticBoxSizer,
58980 _swigc__p_wxStdDialogButtonSizer,
58981 _swigc__p_wxSysColourChangedEvent,
58982 _swigc__p_wxTGAHandler,
58983 _swigc__p_wxTIFFHandler,
58984 _swigc__p_wxToolTip,
58985 _swigc__p_wxUpdateUIEvent,
58986 _swigc__p_wxValidator,
58987 _swigc__p_wxVisualAttributes,
58988 _swigc__p_wxWindow,
58989 _swigc__p_wxWindowCreateEvent,
58990 _swigc__p_wxWindowDestroyEvent,
58991 _swigc__p_wxXPMHandler,
58992 _swigc__p_wxZipFSHandler,
58993 };
58994
58995
58996 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
58997
58998 static swig_const_info swig_const_table[] = {
58999 {0, 0, 0, 0.0, 0, 0}};
59000
59001 #ifdef __cplusplus
59002 }
59003 #endif
59004 /* -----------------------------------------------------------------------------
59005 * Type initialization:
59006 * This problem is tough by the requirement that no dynamic
59007 * memory is used. Also, since swig_type_info structures store pointers to
59008 * swig_cast_info structures and swig_cast_info structures store pointers back
59009 * to swig_type_info structures, we need some lookup code at initialization.
59010 * The idea is that swig generates all the structures that are needed.
59011 * The runtime then collects these partially filled structures.
59012 * The SWIG_InitializeModule function takes these initial arrays out of
59013 * swig_module, and does all the lookup, filling in the swig_module.types
59014 * array with the correct data and linking the correct swig_cast_info
59015 * structures together.
59016 *
59017 * The generated swig_type_info structures are assigned staticly to an initial
59018 * array. We just loop though that array, and handle each type individually.
59019 * First we lookup if this type has been already loaded, and if so, use the
59020 * loaded structure instead of the generated one. Then we have to fill in the
59021 * cast linked list. The cast data is initially stored in something like a
59022 * two-dimensional array. Each row corresponds to a type (there are the same
59023 * number of rows as there are in the swig_type_initial array). Each entry in
59024 * a column is one of the swig_cast_info structures for that type.
59025 * The cast_initial array is actually an array of arrays, because each row has
59026 * a variable number of columns. So to actually build the cast linked list,
59027 * we find the array of casts associated with the type, and loop through it
59028 * adding the casts to the list. The one last trick we need to do is making
59029 * sure the type pointer in the swig_cast_info struct is correct.
59030 *
59031 * First off, we lookup the cast->type name to see if it is already loaded.
59032 * There are three cases to handle:
59033 * 1) If the cast->type has already been loaded AND the type we are adding
59034 * casting info to has not been loaded (it is in this module), THEN we
59035 * replace the cast->type pointer with the type pointer that has already
59036 * been loaded.
59037 * 2) If BOTH types (the one we are adding casting info to, and the
59038 * cast->type) are loaded, THEN the cast info has already been loaded by
59039 * the previous module so we just ignore it.
59040 * 3) Finally, if cast->type has not already been loaded, then we add that
59041 * swig_cast_info to the linked list (because the cast->type) pointer will
59042 * be correct.
59043 * ----------------------------------------------------------------------------- */
59044
59045 #ifdef __cplusplus
59046 extern "C" {
59047 #if 0
59048 } /* c-mode */
59049 #endif
59050 #endif
59051
59052 #if 0
59053 #define SWIGRUNTIME_DEBUG
59054 #endif
59055
59056 SWIGRUNTIME void
59057 SWIG_InitializeModule(void *clientdata) {
59058 size_t i;
59059 swig_module_info *module_head;
59060 static int init_run = 0;
59061
59062 clientdata = clientdata;
59063
59064 if (init_run) return;
59065 init_run = 1;
59066
59067 /* Initialize the swig_module */
59068 swig_module.type_initial = swig_type_initial;
59069 swig_module.cast_initial = swig_cast_initial;
59070
59071 /* Try and load any already created modules */
59072 module_head = SWIG_GetModule(clientdata);
59073 if (module_head) {
59074 swig_module.next = module_head->next;
59075 module_head->next = &swig_module;
59076 } else {
59077 /* This is the first module loaded */
59078 swig_module.next = &swig_module;
59079 SWIG_SetModule(clientdata, &swig_module);
59080 }
59081
59082 /* Now work on filling in swig_module.types */
59083 #ifdef SWIGRUNTIME_DEBUG
59084 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59085 #endif
59086 for (i = 0; i < swig_module.size; ++i) {
59087 swig_type_info *type = 0;
59088 swig_type_info *ret;
59089 swig_cast_info *cast;
59090
59091 #ifdef SWIGRUNTIME_DEBUG
59092 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59093 #endif
59094
59095 /* if there is another module already loaded */
59096 if (swig_module.next != &swig_module) {
59097 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59098 }
59099 if (type) {
59100 /* Overwrite clientdata field */
59101 #ifdef SWIGRUNTIME_DEBUG
59102 printf("SWIG_InitializeModule: found type %s\n", type->name);
59103 #endif
59104 if (swig_module.type_initial[i]->clientdata) {
59105 type->clientdata = swig_module.type_initial[i]->clientdata;
59106 #ifdef SWIGRUNTIME_DEBUG
59107 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59108 #endif
59109 }
59110 } else {
59111 type = swig_module.type_initial[i];
59112 }
59113
59114 /* Insert casting types */
59115 cast = swig_module.cast_initial[i];
59116 while (cast->type) {
59117 /* Don't need to add information already in the list */
59118 ret = 0;
59119 #ifdef SWIGRUNTIME_DEBUG
59120 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59121 #endif
59122 if (swig_module.next != &swig_module) {
59123 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59124 #ifdef SWIGRUNTIME_DEBUG
59125 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59126 #endif
59127 }
59128 if (ret) {
59129 if (type == swig_module.type_initial[i]) {
59130 #ifdef SWIGRUNTIME_DEBUG
59131 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59132 #endif
59133 cast->type = ret;
59134 ret = 0;
59135 } else {
59136 /* Check for casting already in the list */
59137 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59138 #ifdef SWIGRUNTIME_DEBUG
59139 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59140 #endif
59141 if (!ocast) ret = 0;
59142 }
59143 }
59144
59145 if (!ret) {
59146 #ifdef SWIGRUNTIME_DEBUG
59147 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59148 #endif
59149 if (type->cast) {
59150 type->cast->prev = cast;
59151 cast->next = type->cast;
59152 }
59153 type->cast = cast;
59154 }
59155 cast++;
59156 }
59157 /* Set entry in modules->types array equal to the type */
59158 swig_module.types[i] = type;
59159 }
59160 swig_module.types[i] = 0;
59161
59162 #ifdef SWIGRUNTIME_DEBUG
59163 printf("**** SWIG_InitializeModule: Cast List ******\n");
59164 for (i = 0; i < swig_module.size; ++i) {
59165 int j = 0;
59166 swig_cast_info *cast = swig_module.cast_initial[i];
59167 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59168 while (cast->type) {
59169 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59170 cast++;
59171 ++j;
59172 }
59173 printf("---- Total casts: %d\n",j);
59174 }
59175 printf("**** SWIG_InitializeModule: Cast List ******\n");
59176 #endif
59177 }
59178
59179 /* This function will propagate the clientdata field of type to
59180 * any new swig_type_info structures that have been added into the list
59181 * of equivalent types. It is like calling
59182 * SWIG_TypeClientData(type, clientdata) a second time.
59183 */
59184 SWIGRUNTIME void
59185 SWIG_PropagateClientData(void) {
59186 size_t i;
59187 swig_cast_info *equiv;
59188 static int init_run = 0;
59189
59190 if (init_run) return;
59191 init_run = 1;
59192
59193 for (i = 0; i < swig_module.size; i++) {
59194 if (swig_module.types[i]->clientdata) {
59195 equiv = swig_module.types[i]->cast;
59196 while (equiv) {
59197 if (!equiv->converter) {
59198 if (equiv->type && !equiv->type->clientdata)
59199 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59200 }
59201 equiv = equiv->next;
59202 }
59203 }
59204 }
59205 }
59206
59207 #ifdef __cplusplus
59208 #if 0
59209 {
59210 /* c-mode */
59211 #endif
59212 }
59213 #endif
59214
59215
59216
59217 #ifdef __cplusplus
59218 extern "C" {
59219 #endif
59220
59221 /* Python-specific SWIG API */
59222 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59223 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59224 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59225
59226 /* -----------------------------------------------------------------------------
59227 * global variable support code.
59228 * ----------------------------------------------------------------------------- */
59229
59230 typedef struct swig_globalvar {
59231 char *name; /* Name of global variable */
59232 PyObject *(*get_attr)(void); /* Return the current value */
59233 int (*set_attr)(PyObject *); /* Set the value */
59234 struct swig_globalvar *next;
59235 } swig_globalvar;
59236
59237 typedef struct swig_varlinkobject {
59238 PyObject_HEAD
59239 swig_globalvar *vars;
59240 } swig_varlinkobject;
59241
59242 SWIGINTERN PyObject *
59243 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59244 return PyString_FromString("<Swig global variables>");
59245 }
59246
59247 SWIGINTERN PyObject *
59248 swig_varlink_str(swig_varlinkobject *v) {
59249 PyObject *str = PyString_FromString("(");
59250 swig_globalvar *var;
59251 for (var = v->vars; var; var=var->next) {
59252 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59253 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59254 }
59255 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59256 return str;
59257 }
59258
59259 SWIGINTERN int
59260 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59261 PyObject *str = swig_varlink_str(v);
59262 fprintf(fp,"Swig global variables ");
59263 fprintf(fp,"%s\n", PyString_AsString(str));
59264 Py_DECREF(str);
59265 return 0;
59266 }
59267
59268 SWIGINTERN void
59269 swig_varlink_dealloc(swig_varlinkobject *v) {
59270 swig_globalvar *var = v->vars;
59271 while (var) {
59272 swig_globalvar *n = var->next;
59273 free(var->name);
59274 free(var);
59275 var = n;
59276 }
59277 }
59278
59279 SWIGINTERN PyObject *
59280 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59281 PyObject *res = NULL;
59282 swig_globalvar *var = v->vars;
59283 while (var) {
59284 if (strcmp(var->name,n) == 0) {
59285 res = (*var->get_attr)();
59286 break;
59287 }
59288 var = var->next;
59289 }
59290 if (res == NULL && !PyErr_Occurred()) {
59291 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59292 }
59293 return res;
59294 }
59295
59296 SWIGINTERN int
59297 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59298 int res = 1;
59299 swig_globalvar *var = v->vars;
59300 while (var) {
59301 if (strcmp(var->name,n) == 0) {
59302 res = (*var->set_attr)(p);
59303 break;
59304 }
59305 var = var->next;
59306 }
59307 if (res == 1 && !PyErr_Occurred()) {
59308 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59309 }
59310 return res;
59311 }
59312
59313 SWIGINTERN PyTypeObject*
59314 swig_varlink_type(void) {
59315 static char varlink__doc__[] = "Swig var link object";
59316 static PyTypeObject varlink_type;
59317 static int type_init = 0;
59318 if (!type_init) {
59319 const PyTypeObject tmp
59320 = {
59321 PyObject_HEAD_INIT(NULL)
59322 0, /* Number of items in variable part (ob_size) */
59323 (char *)"swigvarlink", /* Type name (tp_name) */
59324 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59325 0, /* Itemsize (tp_itemsize) */
59326 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59327 (printfunc) swig_varlink_print, /* Print (tp_print) */
59328 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59329 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59330 0, /* tp_compare */
59331 (reprfunc) swig_varlink_repr, /* tp_repr */
59332 0, /* tp_as_number */
59333 0, /* tp_as_sequence */
59334 0, /* tp_as_mapping */
59335 0, /* tp_hash */
59336 0, /* tp_call */
59337 (reprfunc)swig_varlink_str, /* tp_str */
59338 0, /* tp_getattro */
59339 0, /* tp_setattro */
59340 0, /* tp_as_buffer */
59341 0, /* tp_flags */
59342 varlink__doc__, /* tp_doc */
59343 0, /* tp_traverse */
59344 0, /* tp_clear */
59345 0, /* tp_richcompare */
59346 0, /* tp_weaklistoffset */
59347 #if PY_VERSION_HEX >= 0x02020000
59348 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59349 #endif
59350 #if PY_VERSION_HEX >= 0x02030000
59351 0, /* tp_del */
59352 #endif
59353 #ifdef COUNT_ALLOCS
59354 0,0,0,0 /* tp_alloc -> tp_next */
59355 #endif
59356 };
59357 varlink_type = tmp;
59358 varlink_type.ob_type = &PyType_Type;
59359 type_init = 1;
59360 }
59361 return &varlink_type;
59362 }
59363
59364 /* Create a variable linking object for use later */
59365 SWIGINTERN PyObject *
59366 SWIG_Python_newvarlink(void) {
59367 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59368 if (result) {
59369 result->vars = 0;
59370 }
59371 return ((PyObject*) result);
59372 }
59373
59374 SWIGINTERN void
59375 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59376 swig_varlinkobject *v = (swig_varlinkobject *) p;
59377 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59378 if (gv) {
59379 size_t size = strlen(name)+1;
59380 gv->name = (char *)malloc(size);
59381 if (gv->name) {
59382 strncpy(gv->name,name,size);
59383 gv->get_attr = get_attr;
59384 gv->set_attr = set_attr;
59385 gv->next = v->vars;
59386 }
59387 }
59388 v->vars = gv;
59389 }
59390
59391 SWIGINTERN PyObject *
59392 SWIG_globals() {
59393 static PyObject *_SWIG_globals = 0;
59394 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59395 return _SWIG_globals;
59396 }
59397
59398 /* -----------------------------------------------------------------------------
59399 * constants/methods manipulation
59400 * ----------------------------------------------------------------------------- */
59401
59402 /* Install Constants */
59403 SWIGINTERN void
59404 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59405 PyObject *obj = 0;
59406 size_t i;
59407 for (i = 0; constants[i].type; ++i) {
59408 switch(constants[i].type) {
59409 case SWIG_PY_POINTER:
59410 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59411 break;
59412 case SWIG_PY_BINARY:
59413 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59414 break;
59415 default:
59416 obj = 0;
59417 break;
59418 }
59419 if (obj) {
59420 PyDict_SetItemString(d, constants[i].name, obj);
59421 Py_DECREF(obj);
59422 }
59423 }
59424 }
59425
59426 /* -----------------------------------------------------------------------------*/
59427 /* Fix SwigMethods to carry the callback ptrs when needed */
59428 /* -----------------------------------------------------------------------------*/
59429
59430 SWIGINTERN void
59431 SWIG_Python_FixMethods(PyMethodDef *methods,
59432 swig_const_info *const_table,
59433 swig_type_info **types,
59434 swig_type_info **types_initial) {
59435 size_t i;
59436 for (i = 0; methods[i].ml_name; ++i) {
59437 const char *c = methods[i].ml_doc;
59438 if (c && (c = strstr(c, "swig_ptr: "))) {
59439 int j;
59440 swig_const_info *ci = 0;
59441 const char *name = c + 10;
59442 for (j = 0; const_table[j].type; ++j) {
59443 if (strncmp(const_table[j].name, name,
59444 strlen(const_table[j].name)) == 0) {
59445 ci = &(const_table[j]);
59446 break;
59447 }
59448 }
59449 if (ci) {
59450 size_t shift = (ci->ptype) - types;
59451 swig_type_info *ty = types_initial[shift];
59452 size_t ldoc = (c - methods[i].ml_doc);
59453 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59454 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59455 if (ndoc) {
59456 char *buff = ndoc;
59457 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59458 if (ptr) {
59459 strncpy(buff, methods[i].ml_doc, ldoc);
59460 buff += ldoc;
59461 strncpy(buff, "swig_ptr: ", 10);
59462 buff += 10;
59463 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59464 methods[i].ml_doc = ndoc;
59465 }
59466 }
59467 }
59468 }
59469 }
59470 }
59471
59472 #ifdef __cplusplus
59473 }
59474 #endif
59475
59476 /* -----------------------------------------------------------------------------*
59477 * Partial Init method
59478 * -----------------------------------------------------------------------------*/
59479
59480 #ifdef __cplusplus
59481 extern "C"
59482 #endif
59483 SWIGEXPORT void SWIG_init(void) {
59484 PyObject *m, *d;
59485
59486 /* Fix SwigMethods to carry the callback ptrs when needed */
59487 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59488
59489 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59490 d = PyModule_GetDict(m);
59491
59492 SWIG_InitializeModule(0);
59493 SWIG_InstallConstants(d,swig_const_table);
59494
59495
59496
59497 #ifndef wxPyUSE_EXPORT
59498 // Make our API structure a CObject so other modules can import it
59499 // from this module.
59500 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59501 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59502 Py_XDECREF(cobj);
59503 #endif
59504
59505 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59506 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59507 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59508 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59509 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59510 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59511 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59512 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59513 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59514 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59515 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59516 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59517 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59518 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59519 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59520 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59521 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59522 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59523 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59524 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59525 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59526 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59527 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59528 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59529 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59530 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59531 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59532 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59533 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59534 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59535 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59536 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59537 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59538 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59539 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59540 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59541 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59542 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59543 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59544 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59545 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59546 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59547 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59548 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59549 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59550 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59551 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59552 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59553 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59554 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59555 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59556 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59557 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59558 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59559 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59560 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59561 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59562 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59563 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59564 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59565 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59566 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59567 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59568 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59569 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59570 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59571 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59572 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59573 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59574 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59575 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59576 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59577 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59578 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59579 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59580 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59581 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59582 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59583 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59584 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59585 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59586 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59587 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59588 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59589 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59590 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59591 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59592 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59593 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59594 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59595 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59596 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59597 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59598 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59599 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59600 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59601 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59602 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59603 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59604 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59605 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59606 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59607 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59608 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59609 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59610 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59611 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59612 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59613 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59614 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59615 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59616 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59617 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59618 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59619 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59620 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59621 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59622 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59623 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59624 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59625 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59626 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59627 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59628 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59629 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59630 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59631 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59632 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59633 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59634 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59635 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59636 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59637 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59638 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59639 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59640 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59641 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59642 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59643 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59644 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59645 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59646 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59647 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59648 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59649 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59650 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59651 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59652 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59653 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59654 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59655 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59656 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59657 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59658 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59659 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59660 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59661 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59662 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59663 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59664 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59665 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59666 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59667 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59668 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59669 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59670 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59671 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59672 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59673 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59674 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59675 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59676 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59677 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59678 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59679 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59680 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59681 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59682 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59683 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59684 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59685 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59686 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59687 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59688 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59689 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59690 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59691 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59692 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59693 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59694 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59695 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59696 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59697 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59698 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59699 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59700 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59701 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59702 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59703 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59704 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59705 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59706 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59707 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59708 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59709 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59710 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59711 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59712 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59713 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59714 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59715 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59716 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59717 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59718 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59719 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59720 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59721 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59722 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59723 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59724 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59725 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59726 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59727 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59728 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59729 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59730 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59731 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59732 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59733 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59734 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59735 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59736 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59737 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59738 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59739 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59740 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59741 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59742 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59743 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59744 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59745 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59746 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59747 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59748 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59749 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59750 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59751 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59752 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59753 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59754 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59755 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59756 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59757 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59758 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59759 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59760 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59761 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59762 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59763 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59764 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59765 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59766 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59767 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59768 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59769 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59770 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59771 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59772 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59773 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59774 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59775 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59776 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59777 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59778 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59779 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59780 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59781 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59782 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59783 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59784 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59785 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59786 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59787 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59788 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59789 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59790 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59791 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59792 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59793 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59794 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59795 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59796 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59797 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59798 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59799 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59800 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59801 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59802 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59803 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59804 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59805 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59806 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59807 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59808 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59809 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59810 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59811 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59812 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59813 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59814 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59815 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59816 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59817 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59818 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59819 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59820 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59821 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59822 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59823 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59824 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59825 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59826 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59827 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59828 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59829 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59830 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59831 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59832 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59833 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59834 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59835 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59836 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59837 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59838 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59839 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59840 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59841 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59842 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59843 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59844 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59845 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59846 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59847 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59848 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59849 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59850 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59851 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59852 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59853 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59854 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59855 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59856 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59857 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59858 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59859 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59860 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59861 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59862 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59863 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59864 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59865 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59866 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59867 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59868 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59869 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59870 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59871 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59872 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59873 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59874 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59875 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59876 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59877 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59878 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59879 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59880 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59881 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59882 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59883 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59884 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59885 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59886 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59887 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59888 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59889 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59890 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59891 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59892 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59893 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59894 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59895 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59896 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59897 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59898 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59914 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59916 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59917 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59918 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59919 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59920 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59921 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59922 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59923 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59924 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59925 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59926 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59927 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59928 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59929 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59930 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59931 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59932 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59933 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59934 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59935 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59936 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59937 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59938 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59939 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59940 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59941 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59942 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59943 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59944 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59945 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59946 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59947 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59948 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59949 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59950 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59951 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59952 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59953 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59954 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59955 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59956 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59957 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59958 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59959 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59960 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59961 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59962 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59963 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59964 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59965 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59966 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59967 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59968 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59969 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59970 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59971 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59972 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59973 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59974 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59975 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59976 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59977 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59978 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59979 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59980 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59981 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59982 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59983 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
59984 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
59985 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
59986 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
59987 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
59988 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
59989 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
59990 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
59991 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
59992 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
59993 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
59994 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
59995 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
59996 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
59997 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
59998 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
59999 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60000 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60001 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60002 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60003 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60004 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60005 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60006 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60007 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60008 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60009 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60010 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60011 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60012 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60013 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60014 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60015 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60016 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60017 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60018 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60019 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60020 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60021 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60022 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60023 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60024 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60025 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60026 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60027 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60028 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60029 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60030 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60031 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60032 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60033 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60034 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60035 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60036 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60037 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60038 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60039 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60040 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60041 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60042 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60043 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60044 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60045 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60046 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60047 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60048 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60049 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60050 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60051 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60052 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60053 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60054 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60055 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60056 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60057 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60058 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60059 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60060 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60061 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60062 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60063 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60064 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60065 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60066 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60067 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60068 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60069 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60070 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60071 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60072 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60073 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60074 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60075 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60076 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60077 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60078 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60079 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60080 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60081 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60082 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60083 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60084 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60085 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60086 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60087 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60088 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60089 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60090 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60091 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60092 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60093 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60094 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60095 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60096 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60097 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60098 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60099 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60100 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60101 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60102 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60103 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60104 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60105 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60106 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60107 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60108 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60109 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60110 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60116 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60117 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60118 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60119 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60120 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60121 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60122 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60123 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60124 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60125 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60126 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60127 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60128 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60129 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60130 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60131 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60132 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60133 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60134 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60135 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60136 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60137 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60138 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60139 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60140 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60141 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60142 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60143 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60144 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60145 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60146 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60147 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60148 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60149 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60150 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60151 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60152 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60153 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60154 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60155 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60156 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60157 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60158 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60159 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60160 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60161 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60162 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60163 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60164 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60165 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60166 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60167 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60168 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60169 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60170
60171 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60172
60173
60174 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60175
60176 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60177 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60178 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60179 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60180 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60181 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60182 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60184 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60185 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60186 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60187 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60188 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60189 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60190 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60191 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60192 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60193 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60194 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60195 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60196 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60197 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60198 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60199 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60200 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60201 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60202 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60203 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60204 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60205 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60206 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60207 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60208 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60209 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60210 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60211 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60212 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60213 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60214 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60215 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60216 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60217 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60218 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60219 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60220 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60221 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60222 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60223 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60224 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60225 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60226 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60227 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60228 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60229 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60230 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60231 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60232 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60233 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60234 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60235 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60236 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60237 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60238 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60239 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60240 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60241 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60242 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60243 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60244 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60245 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60246 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60247 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60248 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60249 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60250 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60251 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60252 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60253 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60254 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60255 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60256 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60257 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60258 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60259 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60260 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60261 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60262 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60263 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60264 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60265 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60266 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60267 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60268 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60269 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60270 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60271 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60272 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60273 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60274 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60275 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60276 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60277 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60278 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60279 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60280 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60281 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60282 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60283 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60284 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60285 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60286 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60287 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60288 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60289 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60290 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60291 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60292 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60293 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60294 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60295 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60296 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60297 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60298 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60299 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60300 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60301 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60302 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60303 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60304 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60305 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60306 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60307 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60308 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60309 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60310 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60311 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60312 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60313 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60314 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60315 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60316 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60317 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60318 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60319 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60320 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60321 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60322 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60323 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60324 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60325 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60326 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60327 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60328 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60329 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60330 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60331 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60332 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60333 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60334 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60335 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60336 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60337 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60338 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60339 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60340 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60341 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60342 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60343 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60344 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60345 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60346 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60347 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60348 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60349 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60350 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60351 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60352 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60353 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60354 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60355 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60356 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60357 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60358 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60359 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60360 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60361 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60362 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60363 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60364 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60365 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60366 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60367 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60368 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60369 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60370 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60371 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60372 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60373 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60374 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60375 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60376 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60377 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60378 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60379 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60380 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60381 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60382 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60383 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60384 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60385 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60386 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60387 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60388 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60389 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60390
60391 // Initialize threading, some globals and such
60392 __wxPyPreStart(d);
60393
60394
60395 // Although these are defined in __version__ they need to be here too so
60396 // that an assert can be done to ensure that the wxPython and the wxWindows
60397 // versions match.
60398 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60399 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60400 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60401
60402 }
60403
wxWidgets (Impactor)