]> 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
fixes for the dummy classes (used when wxUSE_GRAPHICS_CONTEXT is 0)
[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,unsigned 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,unsigned 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,unsigned 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 ;
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 *)"OOOO: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 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29980 if (!SWIG_IsOK(ecode4)) {
29981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29982 }
29983 arg4 = static_cast< bool >(val4);
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 resultobj = SWIG_Py_Void();
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29998 PyObject *resultobj = 0;
29999 wxPyApp *arg1 = (wxPyApp *) 0 ;
30000 wxString result;
30001 void *argp1 = 0 ;
30002 int res1 = 0 ;
30003 PyObject *swig_obj[1] ;
30004
30005 if (!args) SWIG_fail;
30006 swig_obj[0] = args;
30007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30008 if (!SWIG_IsOK(res1)) {
30009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30010 }
30011 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30012 {
30013 PyThreadState* __tstate = wxPyBeginAllowThreads();
30014 result = ((wxPyApp const *)arg1)->GetAppName();
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 {
30019 #if wxUSE_UNICODE
30020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30021 #else
30022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30023 #endif
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj = 0;
30033 wxPyApp *arg1 = (wxPyApp *) 0 ;
30034 wxString *arg2 = 0 ;
30035 void *argp1 = 0 ;
30036 int res1 = 0 ;
30037 bool temp2 = false ;
30038 PyObject * obj0 = 0 ;
30039 PyObject * obj1 = 0 ;
30040 char * kwnames[] = {
30041 (char *) "self",(char *) "name", NULL
30042 };
30043
30044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30046 if (!SWIG_IsOK(res1)) {
30047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30048 }
30049 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30050 {
30051 arg2 = wxString_in_helper(obj1);
30052 if (arg2 == NULL) SWIG_fail;
30053 temp2 = true;
30054 }
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 (arg1)->SetAppName((wxString const &)*arg2);
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 resultobj = SWIG_Py_Void();
30062 {
30063 if (temp2)
30064 delete arg2;
30065 }
30066 return resultobj;
30067 fail:
30068 {
30069 if (temp2)
30070 delete arg2;
30071 }
30072 return NULL;
30073 }
30074
30075
30076 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30077 PyObject *resultobj = 0;
30078 wxPyApp *arg1 = (wxPyApp *) 0 ;
30079 wxString result;
30080 void *argp1 = 0 ;
30081 int res1 = 0 ;
30082 PyObject *swig_obj[1] ;
30083
30084 if (!args) SWIG_fail;
30085 swig_obj[0] = args;
30086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30087 if (!SWIG_IsOK(res1)) {
30088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30089 }
30090 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30091 {
30092 PyThreadState* __tstate = wxPyBeginAllowThreads();
30093 result = ((wxPyApp const *)arg1)->GetClassName();
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 {
30098 #if wxUSE_UNICODE
30099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30100 #else
30101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30102 #endif
30103 }
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30111 PyObject *resultobj = 0;
30112 wxPyApp *arg1 = (wxPyApp *) 0 ;
30113 wxString *arg2 = 0 ;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 bool temp2 = false ;
30117 PyObject * obj0 = 0 ;
30118 PyObject * obj1 = 0 ;
30119 char * kwnames[] = {
30120 (char *) "self",(char *) "name", NULL
30121 };
30122
30123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30125 if (!SWIG_IsOK(res1)) {
30126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30127 }
30128 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30129 {
30130 arg2 = wxString_in_helper(obj1);
30131 if (arg2 == NULL) SWIG_fail;
30132 temp2 = true;
30133 }
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 (arg1)->SetClassName((wxString const &)*arg2);
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_Py_Void();
30141 {
30142 if (temp2)
30143 delete arg2;
30144 }
30145 return resultobj;
30146 fail:
30147 {
30148 if (temp2)
30149 delete arg2;
30150 }
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30156 PyObject *resultobj = 0;
30157 wxPyApp *arg1 = (wxPyApp *) 0 ;
30158 wxString *result = 0 ;
30159 void *argp1 = 0 ;
30160 int res1 = 0 ;
30161 PyObject *swig_obj[1] ;
30162
30163 if (!args) SWIG_fail;
30164 swig_obj[0] = args;
30165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30168 }
30169 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 {
30173 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30174 result = (wxString *) &_result_ref;
30175 }
30176 wxPyEndAllowThreads(__tstate);
30177 if (PyErr_Occurred()) SWIG_fail;
30178 }
30179 {
30180 #if wxUSE_UNICODE
30181 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30182 #else
30183 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30184 #endif
30185 }
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30193 PyObject *resultobj = 0;
30194 wxPyApp *arg1 = (wxPyApp *) 0 ;
30195 wxString *arg2 = 0 ;
30196 void *argp1 = 0 ;
30197 int res1 = 0 ;
30198 bool temp2 = false ;
30199 PyObject * obj0 = 0 ;
30200 PyObject * obj1 = 0 ;
30201 char * kwnames[] = {
30202 (char *) "self",(char *) "name", NULL
30203 };
30204
30205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30207 if (!SWIG_IsOK(res1)) {
30208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30209 }
30210 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30211 {
30212 arg2 = wxString_in_helper(obj1);
30213 if (arg2 == NULL) SWIG_fail;
30214 temp2 = true;
30215 }
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 (arg1)->SetVendorName((wxString const &)*arg2);
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 resultobj = SWIG_Py_Void();
30223 {
30224 if (temp2)
30225 delete arg2;
30226 }
30227 return resultobj;
30228 fail:
30229 {
30230 if (temp2)
30231 delete arg2;
30232 }
30233 return NULL;
30234 }
30235
30236
30237 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30238 PyObject *resultobj = 0;
30239 wxPyApp *arg1 = (wxPyApp *) 0 ;
30240 wxAppTraits *result = 0 ;
30241 void *argp1 = 0 ;
30242 int res1 = 0 ;
30243 PyObject *swig_obj[1] ;
30244
30245 if (!args) SWIG_fail;
30246 swig_obj[0] = args;
30247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30248 if (!SWIG_IsOK(res1)) {
30249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30250 }
30251 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 result = (wxAppTraits *)(arg1)->GetTraits();
30255 wxPyEndAllowThreads(__tstate);
30256 if (PyErr_Occurred()) SWIG_fail;
30257 }
30258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30259 return resultobj;
30260 fail:
30261 return NULL;
30262 }
30263
30264
30265 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30266 PyObject *resultobj = 0;
30267 wxPyApp *arg1 = (wxPyApp *) 0 ;
30268 void *argp1 = 0 ;
30269 int res1 = 0 ;
30270 PyObject *swig_obj[1] ;
30271
30272 if (!args) SWIG_fail;
30273 swig_obj[0] = args;
30274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30275 if (!SWIG_IsOK(res1)) {
30276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30277 }
30278 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 (arg1)->ProcessPendingEvents();
30282 wxPyEndAllowThreads(__tstate);
30283 if (PyErr_Occurred()) SWIG_fail;
30284 }
30285 resultobj = SWIG_Py_Void();
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30293 PyObject *resultobj = 0;
30294 wxPyApp *arg1 = (wxPyApp *) 0 ;
30295 bool arg2 = (bool) false ;
30296 bool result;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 bool val2 ;
30300 int ecode2 = 0 ;
30301 PyObject * obj0 = 0 ;
30302 PyObject * obj1 = 0 ;
30303 char * kwnames[] = {
30304 (char *) "self",(char *) "onlyIfNeeded", NULL
30305 };
30306
30307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30309 if (!SWIG_IsOK(res1)) {
30310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30311 }
30312 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30313 if (obj1) {
30314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30315 if (!SWIG_IsOK(ecode2)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30317 }
30318 arg2 = static_cast< bool >(val2);
30319 }
30320 {
30321 PyThreadState* __tstate = wxPyBeginAllowThreads();
30322 result = (bool)(arg1)->Yield(arg2);
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 {
30327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30328 }
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30336 PyObject *resultobj = 0;
30337 wxPyApp *arg1 = (wxPyApp *) 0 ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 PyObject *swig_obj[1] ;
30341
30342 if (!args) SWIG_fail;
30343 swig_obj[0] = args;
30344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30345 if (!SWIG_IsOK(res1)) {
30346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30347 }
30348 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 (arg1)->WakeUpIdle();
30352 wxPyEndAllowThreads(__tstate);
30353 if (PyErr_Occurred()) SWIG_fail;
30354 }
30355 resultobj = SWIG_Py_Void();
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30363 PyObject *resultobj = 0;
30364 bool result;
30365
30366 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (bool)wxPyApp::IsMainLoopRunning();
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 {
30374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30375 }
30376 return resultobj;
30377 fail:
30378 return NULL;
30379 }
30380
30381
30382 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30383 PyObject *resultobj = 0;
30384 wxPyApp *arg1 = (wxPyApp *) 0 ;
30385 int result;
30386 void *argp1 = 0 ;
30387 int res1 = 0 ;
30388 PyObject *swig_obj[1] ;
30389
30390 if (!args) SWIG_fail;
30391 swig_obj[0] = args;
30392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30393 if (!SWIG_IsOK(res1)) {
30394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30395 }
30396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 result = (int)(arg1)->MainLoop();
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 resultobj = SWIG_From_int(static_cast< int >(result));
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30411 PyObject *resultobj = 0;
30412 wxPyApp *arg1 = (wxPyApp *) 0 ;
30413 void *argp1 = 0 ;
30414 int res1 = 0 ;
30415 PyObject *swig_obj[1] ;
30416
30417 if (!args) SWIG_fail;
30418 swig_obj[0] = args;
30419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30420 if (!SWIG_IsOK(res1)) {
30421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30422 }
30423 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30424 {
30425 PyThreadState* __tstate = wxPyBeginAllowThreads();
30426 (arg1)->Exit();
30427 wxPyEndAllowThreads(__tstate);
30428 if (PyErr_Occurred()) SWIG_fail;
30429 }
30430 resultobj = SWIG_Py_Void();
30431 return resultobj;
30432 fail:
30433 return NULL;
30434 }
30435
30436
30437 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30438 PyObject *resultobj = 0;
30439 wxPyApp *arg1 = (wxPyApp *) 0 ;
30440 wxLayoutDirection result;
30441 void *argp1 = 0 ;
30442 int res1 = 0 ;
30443 PyObject *swig_obj[1] ;
30444
30445 if (!args) SWIG_fail;
30446 swig_obj[0] = args;
30447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30448 if (!SWIG_IsOK(res1)) {
30449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30450 }
30451 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30452 {
30453 PyThreadState* __tstate = wxPyBeginAllowThreads();
30454 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30455 wxPyEndAllowThreads(__tstate);
30456 if (PyErr_Occurred()) SWIG_fail;
30457 }
30458 resultobj = SWIG_From_int(static_cast< int >(result));
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30466 PyObject *resultobj = 0;
30467 wxPyApp *arg1 = (wxPyApp *) 0 ;
30468 void *argp1 = 0 ;
30469 int res1 = 0 ;
30470 PyObject *swig_obj[1] ;
30471
30472 if (!args) SWIG_fail;
30473 swig_obj[0] = args;
30474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30475 if (!SWIG_IsOK(res1)) {
30476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30477 }
30478 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30479 {
30480 PyThreadState* __tstate = wxPyBeginAllowThreads();
30481 (arg1)->ExitMainLoop();
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_Py_Void();
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30493 PyObject *resultobj = 0;
30494 wxPyApp *arg1 = (wxPyApp *) 0 ;
30495 bool result;
30496 void *argp1 = 0 ;
30497 int res1 = 0 ;
30498 PyObject *swig_obj[1] ;
30499
30500 if (!args) SWIG_fail;
30501 swig_obj[0] = args;
30502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30503 if (!SWIG_IsOK(res1)) {
30504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30505 }
30506 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 result = (bool)(arg1)->Pending();
30510 wxPyEndAllowThreads(__tstate);
30511 if (PyErr_Occurred()) SWIG_fail;
30512 }
30513 {
30514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30515 }
30516 return resultobj;
30517 fail:
30518 return NULL;
30519 }
30520
30521
30522 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30523 PyObject *resultobj = 0;
30524 wxPyApp *arg1 = (wxPyApp *) 0 ;
30525 bool result;
30526 void *argp1 = 0 ;
30527 int res1 = 0 ;
30528 PyObject *swig_obj[1] ;
30529
30530 if (!args) SWIG_fail;
30531 swig_obj[0] = args;
30532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30533 if (!SWIG_IsOK(res1)) {
30534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30535 }
30536 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 result = (bool)(arg1)->Dispatch();
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 {
30544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30553 PyObject *resultobj = 0;
30554 wxPyApp *arg1 = (wxPyApp *) 0 ;
30555 bool result;
30556 void *argp1 = 0 ;
30557 int res1 = 0 ;
30558 PyObject *swig_obj[1] ;
30559
30560 if (!args) SWIG_fail;
30561 swig_obj[0] = args;
30562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30563 if (!SWIG_IsOK(res1)) {
30564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30565 }
30566 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 result = (bool)(arg1)->ProcessIdle();
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 {
30574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30575 }
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30583 PyObject *resultobj = 0;
30584 wxPyApp *arg1 = (wxPyApp *) 0 ;
30585 wxWindow *arg2 = (wxWindow *) 0 ;
30586 wxIdleEvent *arg3 = 0 ;
30587 bool result;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 void *argp2 = 0 ;
30591 int res2 = 0 ;
30592 void *argp3 = 0 ;
30593 int res3 = 0 ;
30594 PyObject * obj0 = 0 ;
30595 PyObject * obj1 = 0 ;
30596 PyObject * obj2 = 0 ;
30597 char * kwnames[] = {
30598 (char *) "self",(char *) "win",(char *) "event", NULL
30599 };
30600
30601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30603 if (!SWIG_IsOK(res1)) {
30604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30605 }
30606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30608 if (!SWIG_IsOK(res2)) {
30609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30610 }
30611 arg2 = reinterpret_cast< wxWindow * >(argp2);
30612 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30613 if (!SWIG_IsOK(res3)) {
30614 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30615 }
30616 if (!argp3) {
30617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30618 }
30619 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30623 wxPyEndAllowThreads(__tstate);
30624 if (PyErr_Occurred()) SWIG_fail;
30625 }
30626 {
30627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30628 }
30629 return resultobj;
30630 fail:
30631 return NULL;
30632 }
30633
30634
30635 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30636 PyObject *resultobj = 0;
30637 wxPyApp *arg1 = (wxPyApp *) 0 ;
30638 bool result;
30639 void *argp1 = 0 ;
30640 int res1 = 0 ;
30641 PyObject *swig_obj[1] ;
30642
30643 if (!args) SWIG_fail;
30644 swig_obj[0] = args;
30645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30646 if (!SWIG_IsOK(res1)) {
30647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30648 }
30649 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 result = (bool)((wxPyApp const *)arg1)->IsActive();
30653 wxPyEndAllowThreads(__tstate);
30654 if (PyErr_Occurred()) SWIG_fail;
30655 }
30656 {
30657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30658 }
30659 return resultobj;
30660 fail:
30661 return NULL;
30662 }
30663
30664
30665 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30666 PyObject *resultobj = 0;
30667 wxPyApp *arg1 = (wxPyApp *) 0 ;
30668 wxWindow *arg2 = (wxWindow *) 0 ;
30669 void *argp1 = 0 ;
30670 int res1 = 0 ;
30671 void *argp2 = 0 ;
30672 int res2 = 0 ;
30673 PyObject * obj0 = 0 ;
30674 PyObject * obj1 = 0 ;
30675 char * kwnames[] = {
30676 (char *) "self",(char *) "win", NULL
30677 };
30678
30679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30681 if (!SWIG_IsOK(res1)) {
30682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30683 }
30684 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30686 if (!SWIG_IsOK(res2)) {
30687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30688 }
30689 arg2 = reinterpret_cast< wxWindow * >(argp2);
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 (arg1)->SetTopWindow(arg2);
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 resultobj = SWIG_Py_Void();
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30704 PyObject *resultobj = 0;
30705 wxPyApp *arg1 = (wxPyApp *) 0 ;
30706 wxWindow *result = 0 ;
30707 void *argp1 = 0 ;
30708 int res1 = 0 ;
30709 PyObject *swig_obj[1] ;
30710
30711 if (!args) SWIG_fail;
30712 swig_obj[0] = args;
30713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30714 if (!SWIG_IsOK(res1)) {
30715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30716 }
30717 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30718 {
30719 PyThreadState* __tstate = wxPyBeginAllowThreads();
30720 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 {
30725 resultobj = wxPyMake_wxObject(result, (bool)0);
30726 }
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = 0;
30735 wxPyApp *arg1 = (wxPyApp *) 0 ;
30736 bool arg2 ;
30737 void *argp1 = 0 ;
30738 int res1 = 0 ;
30739 bool val2 ;
30740 int ecode2 = 0 ;
30741 PyObject * obj0 = 0 ;
30742 PyObject * obj1 = 0 ;
30743 char * kwnames[] = {
30744 (char *) "self",(char *) "flag", NULL
30745 };
30746
30747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30749 if (!SWIG_IsOK(res1)) {
30750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30751 }
30752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30754 if (!SWIG_IsOK(ecode2)) {
30755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30756 }
30757 arg2 = static_cast< bool >(val2);
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 (arg1)->SetExitOnFrameDelete(arg2);
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_Py_Void();
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 wxPyApp *arg1 = (wxPyApp *) 0 ;
30774 bool result;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 PyObject *swig_obj[1] ;
30778
30779 if (!args) SWIG_fail;
30780 swig_obj[0] = args;
30781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30784 }
30785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30794 }
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj = 0;
30803 wxPyApp *arg1 = (wxPyApp *) 0 ;
30804 bool arg2 ;
30805 void *argp1 = 0 ;
30806 int res1 = 0 ;
30807 bool val2 ;
30808 int ecode2 = 0 ;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 char * kwnames[] = {
30812 (char *) "self",(char *) "flag", NULL
30813 };
30814
30815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30817 if (!SWIG_IsOK(res1)) {
30818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30819 }
30820 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30822 if (!SWIG_IsOK(ecode2)) {
30823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30824 }
30825 arg2 = static_cast< bool >(val2);
30826 {
30827 PyThreadState* __tstate = wxPyBeginAllowThreads();
30828 (arg1)->SetUseBestVisual(arg2);
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 resultobj = SWIG_Py_Void();
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30840 PyObject *resultobj = 0;
30841 wxPyApp *arg1 = (wxPyApp *) 0 ;
30842 bool result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30852 }
30853 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj = 0;
30871 wxPyApp *arg1 = (wxPyApp *) 0 ;
30872 int arg2 ;
30873 void *argp1 = 0 ;
30874 int res1 = 0 ;
30875 int val2 ;
30876 int ecode2 = 0 ;
30877 PyObject * obj0 = 0 ;
30878 PyObject * obj1 = 0 ;
30879 char * kwnames[] = {
30880 (char *) "self",(char *) "mode", NULL
30881 };
30882
30883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30885 if (!SWIG_IsOK(res1)) {
30886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30887 }
30888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30889 ecode2 = SWIG_AsVal_int(obj1, &val2);
30890 if (!SWIG_IsOK(ecode2)) {
30891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30892 }
30893 arg2 = static_cast< int >(val2);
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 (arg1)->SetPrintMode(arg2);
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 resultobj = SWIG_Py_Void();
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30908 PyObject *resultobj = 0;
30909 wxPyApp *arg1 = (wxPyApp *) 0 ;
30910 int result;
30911 void *argp1 = 0 ;
30912 int res1 = 0 ;
30913 PyObject *swig_obj[1] ;
30914
30915 if (!args) SWIG_fail;
30916 swig_obj[0] = args;
30917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30920 }
30921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 resultobj = SWIG_From_int(static_cast< int >(result));
30929 return resultobj;
30930 fail:
30931 return NULL;
30932 }
30933
30934
30935 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30936 PyObject *resultobj = 0;
30937 wxPyApp *arg1 = (wxPyApp *) 0 ;
30938 int arg2 ;
30939 void *argp1 = 0 ;
30940 int res1 = 0 ;
30941 int val2 ;
30942 int ecode2 = 0 ;
30943 PyObject * obj0 = 0 ;
30944 PyObject * obj1 = 0 ;
30945 char * kwnames[] = {
30946 (char *) "self",(char *) "mode", NULL
30947 };
30948
30949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30951 if (!SWIG_IsOK(res1)) {
30952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30953 }
30954 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30955 ecode2 = SWIG_AsVal_int(obj1, &val2);
30956 if (!SWIG_IsOK(ecode2)) {
30957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30958 }
30959 arg2 = static_cast< int >(val2);
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 (arg1)->SetAssertMode(arg2);
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 resultobj = SWIG_Py_Void();
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30974 PyObject *resultobj = 0;
30975 wxPyApp *arg1 = (wxPyApp *) 0 ;
30976 int result;
30977 void *argp1 = 0 ;
30978 int res1 = 0 ;
30979 PyObject *swig_obj[1] ;
30980
30981 if (!args) SWIG_fail;
30982 swig_obj[0] = args;
30983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30986 }
30987 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30988 {
30989 PyThreadState* __tstate = wxPyBeginAllowThreads();
30990 result = (int)(arg1)->GetAssertMode();
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 resultobj = SWIG_From_int(static_cast< int >(result));
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002 PyObject *resultobj = 0;
31003 bool result;
31004
31005 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31022 PyObject *resultobj = 0;
31023 long result;
31024
31025 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31026 {
31027 PyThreadState* __tstate = wxPyBeginAllowThreads();
31028 result = (long)wxPyApp::GetMacAboutMenuItemId();
31029 wxPyEndAllowThreads(__tstate);
31030 if (PyErr_Occurred()) SWIG_fail;
31031 }
31032 resultobj = SWIG_From_long(static_cast< long >(result));
31033 return resultobj;
31034 fail:
31035 return NULL;
31036 }
31037
31038
31039 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31040 PyObject *resultobj = 0;
31041 long result;
31042
31043 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 resultobj = SWIG_From_long(static_cast< long >(result));
31051 return resultobj;
31052 fail:
31053 return NULL;
31054 }
31055
31056
31057 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31058 PyObject *resultobj = 0;
31059 long result;
31060
31061 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 result = (long)wxPyApp::GetMacExitMenuItemId();
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_From_long(static_cast< long >(result));
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31076 PyObject *resultobj = 0;
31077 wxString result;
31078
31079 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31080 {
31081 PyThreadState* __tstate = wxPyBeginAllowThreads();
31082 result = wxPyApp::GetMacHelpMenuTitleName();
31083 wxPyEndAllowThreads(__tstate);
31084 if (PyErr_Occurred()) SWIG_fail;
31085 }
31086 {
31087 #if wxUSE_UNICODE
31088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31089 #else
31090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31091 #endif
31092 }
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 bool arg1 ;
31102 bool val1 ;
31103 int ecode1 = 0 ;
31104 PyObject * obj0 = 0 ;
31105 char * kwnames[] = {
31106 (char *) "val", NULL
31107 };
31108
31109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31110 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31111 if (!SWIG_IsOK(ecode1)) {
31112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31113 }
31114 arg1 = static_cast< bool >(val1);
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 resultobj = SWIG_Py_Void();
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31129 PyObject *resultobj = 0;
31130 long arg1 ;
31131 long val1 ;
31132 int ecode1 = 0 ;
31133 PyObject * obj0 = 0 ;
31134 char * kwnames[] = {
31135 (char *) "val", NULL
31136 };
31137
31138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31139 ecode1 = SWIG_AsVal_long(obj0, &val1);
31140 if (!SWIG_IsOK(ecode1)) {
31141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31142 }
31143 arg1 = static_cast< long >(val1);
31144 {
31145 PyThreadState* __tstate = wxPyBeginAllowThreads();
31146 wxPyApp::SetMacAboutMenuItemId(arg1);
31147 wxPyEndAllowThreads(__tstate);
31148 if (PyErr_Occurred()) SWIG_fail;
31149 }
31150 resultobj = SWIG_Py_Void();
31151 return resultobj;
31152 fail:
31153 return NULL;
31154 }
31155
31156
31157 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31158 PyObject *resultobj = 0;
31159 long arg1 ;
31160 long val1 ;
31161 int ecode1 = 0 ;
31162 PyObject * obj0 = 0 ;
31163 char * kwnames[] = {
31164 (char *) "val", NULL
31165 };
31166
31167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31168 ecode1 = SWIG_AsVal_long(obj0, &val1);
31169 if (!SWIG_IsOK(ecode1)) {
31170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31171 }
31172 arg1 = static_cast< long >(val1);
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 resultobj = SWIG_Py_Void();
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31187 PyObject *resultobj = 0;
31188 long arg1 ;
31189 long val1 ;
31190 int ecode1 = 0 ;
31191 PyObject * obj0 = 0 ;
31192 char * kwnames[] = {
31193 (char *) "val", NULL
31194 };
31195
31196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31197 ecode1 = SWIG_AsVal_long(obj0, &val1);
31198 if (!SWIG_IsOK(ecode1)) {
31199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31200 }
31201 arg1 = static_cast< long >(val1);
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 wxPyApp::SetMacExitMenuItemId(arg1);
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 resultobj = SWIG_Py_Void();
31209 return resultobj;
31210 fail:
31211 return NULL;
31212 }
31213
31214
31215 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31216 PyObject *resultobj = 0;
31217 wxString *arg1 = 0 ;
31218 bool temp1 = false ;
31219 PyObject * obj0 = 0 ;
31220 char * kwnames[] = {
31221 (char *) "val", NULL
31222 };
31223
31224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31225 {
31226 arg1 = wxString_in_helper(obj0);
31227 if (arg1 == NULL) SWIG_fail;
31228 temp1 = true;
31229 }
31230 {
31231 PyThreadState* __tstate = wxPyBeginAllowThreads();
31232 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 resultobj = SWIG_Py_Void();
31237 {
31238 if (temp1)
31239 delete arg1;
31240 }
31241 return resultobj;
31242 fail:
31243 {
31244 if (temp1)
31245 delete arg1;
31246 }
31247 return NULL;
31248 }
31249
31250
31251 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31252 PyObject *resultobj = 0;
31253 wxPyApp *arg1 = (wxPyApp *) 0 ;
31254 void *argp1 = 0 ;
31255 int res1 = 0 ;
31256 PyObject *swig_obj[1] ;
31257
31258 if (!args) SWIG_fail;
31259 swig_obj[0] = args;
31260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31261 if (!SWIG_IsOK(res1)) {
31262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31263 }
31264 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 (arg1)->_BootstrapApp();
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 resultobj = SWIG_Py_Void();
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31279 PyObject *resultobj = 0;
31280 int result;
31281
31282 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31283 {
31284 PyThreadState* __tstate = wxPyBeginAllowThreads();
31285 result = (int)wxPyApp_GetComCtl32Version();
31286 wxPyEndAllowThreads(__tstate);
31287 if (PyErr_Occurred()) SWIG_fail;
31288 }
31289 resultobj = SWIG_From_int(static_cast< int >(result));
31290 return resultobj;
31291 fail:
31292 return NULL;
31293 }
31294
31295
31296 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31297 PyObject *resultobj = 0;
31298 bool result;
31299
31300 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31301 {
31302 PyThreadState* __tstate = wxPyBeginAllowThreads();
31303 result = (bool)wxPyApp_IsDisplayAvailable();
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 {
31308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31309 }
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31317 PyObject *obj;
31318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31320 return SWIG_Py_Void();
31321 }
31322
31323 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31324 return SWIG_Python_InitShadowInstance(args);
31325 }
31326
31327 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31328 PyObject *resultobj = 0;
31329
31330 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 wxExit();
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 resultobj = SWIG_Py_Void();
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31345 PyObject *resultobj = 0;
31346 bool result;
31347
31348 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31349 {
31350 PyThreadState* __tstate = wxPyBeginAllowThreads();
31351 result = (bool)wxYield();
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 {
31356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31357 }
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31365 PyObject *resultobj = 0;
31366 bool result;
31367
31368 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31369 {
31370 PyThreadState* __tstate = wxPyBeginAllowThreads();
31371 result = (bool)wxYieldIfNeeded();
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 {
31376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31377 }
31378 return resultobj;
31379 fail:
31380 return NULL;
31381 }
31382
31383
31384 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31385 PyObject *resultobj = 0;
31386 wxWindow *arg1 = (wxWindow *) NULL ;
31387 bool arg2 = (bool) false ;
31388 bool result;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 bool val2 ;
31392 int ecode2 = 0 ;
31393 PyObject * obj0 = 0 ;
31394 PyObject * obj1 = 0 ;
31395 char * kwnames[] = {
31396 (char *) "win",(char *) "onlyIfNeeded", NULL
31397 };
31398
31399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31400 if (obj0) {
31401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31402 if (!SWIG_IsOK(res1)) {
31403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31404 }
31405 arg1 = reinterpret_cast< wxWindow * >(argp1);
31406 }
31407 if (obj1) {
31408 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31409 if (!SWIG_IsOK(ecode2)) {
31410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31411 }
31412 arg2 = static_cast< bool >(val2);
31413 }
31414 {
31415 PyThreadState* __tstate = wxPyBeginAllowThreads();
31416 result = (bool)wxSafeYield(arg1,arg2);
31417 wxPyEndAllowThreads(__tstate);
31418 if (PyErr_Occurred()) SWIG_fail;
31419 }
31420 {
31421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31422 }
31423 return resultobj;
31424 fail:
31425 return NULL;
31426 }
31427
31428
31429 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31430 PyObject *resultobj = 0;
31431
31432 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 wxWakeUpIdle();
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 resultobj = SWIG_Py_Void();
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj = 0;
31448 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31449 wxEvent *arg2 = 0 ;
31450 void *argp1 = 0 ;
31451 int res1 = 0 ;
31452 void *argp2 = 0 ;
31453 int res2 = 0 ;
31454 PyObject * obj0 = 0 ;
31455 PyObject * obj1 = 0 ;
31456 char * kwnames[] = {
31457 (char *) "dest",(char *) "event", NULL
31458 };
31459
31460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31462 if (!SWIG_IsOK(res1)) {
31463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31464 }
31465 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31467 if (!SWIG_IsOK(res2)) {
31468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31469 }
31470 if (!argp2) {
31471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31472 }
31473 arg2 = reinterpret_cast< wxEvent * >(argp2);
31474 {
31475 PyThreadState* __tstate = wxPyBeginAllowThreads();
31476 wxPostEvent(arg1,*arg2);
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 resultobj = SWIG_Py_Void();
31481 return resultobj;
31482 fail:
31483 return NULL;
31484 }
31485
31486
31487 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31488 PyObject *resultobj = 0;
31489
31490 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31491 {
31492 PyThreadState* __tstate = wxPyBeginAllowThreads();
31493 wxApp_CleanUp();
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 resultobj = SWIG_Py_Void();
31498 return resultobj;
31499 fail:
31500 return NULL;
31501 }
31502
31503
31504 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31505 PyObject *resultobj = 0;
31506 wxPyApp *result = 0 ;
31507
31508 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31509 {
31510 PyThreadState* __tstate = wxPyBeginAllowThreads();
31511 result = (wxPyApp *)wxPyGetApp();
31512 wxPyEndAllowThreads(__tstate);
31513 if (PyErr_Occurred()) SWIG_fail;
31514 }
31515 {
31516 resultobj = wxPyMake_wxObject(result, 0);
31517 }
31518 return resultobj;
31519 fail:
31520 return NULL;
31521 }
31522
31523
31524 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31525 PyObject *resultobj = 0;
31526 char *arg1 = (char *) 0 ;
31527 int res1 ;
31528 char *buf1 = 0 ;
31529 int alloc1 = 0 ;
31530 PyObject * obj0 = 0 ;
31531 char * kwnames[] = {
31532 (char *) "encoding", NULL
31533 };
31534
31535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31536 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31537 if (!SWIG_IsOK(res1)) {
31538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31539 }
31540 arg1 = buf1;
31541 {
31542 PyThreadState* __tstate = wxPyBeginAllowThreads();
31543 wxSetDefaultPyEncoding((char const *)arg1);
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 resultobj = SWIG_Py_Void();
31548 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31549 return resultobj;
31550 fail:
31551 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31552 return NULL;
31553 }
31554
31555
31556 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31557 PyObject *resultobj = 0;
31558 char *result = 0 ;
31559
31560 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 result = (char *)wxGetDefaultPyEncoding();
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_FromCharPtr(result);
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31575 PyObject *resultobj = 0;
31576 wxEventLoop *result = 0 ;
31577
31578 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 result = (wxEventLoop *)new wxEventLoop();
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31593 PyObject *resultobj = 0;
31594 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 PyObject *swig_obj[1] ;
31598
31599 if (!args) SWIG_fail;
31600 swig_obj[0] = args;
31601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31602 if (!SWIG_IsOK(res1)) {
31603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31604 }
31605 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 delete arg1;
31609
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 resultobj = SWIG_Py_Void();
31614 return resultobj;
31615 fail:
31616 return NULL;
31617 }
31618
31619
31620 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31621 PyObject *resultobj = 0;
31622 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31623 int result;
31624 void *argp1 = 0 ;
31625 int res1 = 0 ;
31626 PyObject *swig_obj[1] ;
31627
31628 if (!args) SWIG_fail;
31629 swig_obj[0] = args;
31630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31631 if (!SWIG_IsOK(res1)) {
31632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31633 }
31634 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 result = (int)(arg1)->Run();
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 resultobj = SWIG_From_int(static_cast< int >(result));
31642 return resultobj;
31643 fail:
31644 return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31649 PyObject *resultobj = 0;
31650 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31651 int arg2 = (int) 0 ;
31652 void *argp1 = 0 ;
31653 int res1 = 0 ;
31654 int val2 ;
31655 int ecode2 = 0 ;
31656 PyObject * obj0 = 0 ;
31657 PyObject * obj1 = 0 ;
31658 char * kwnames[] = {
31659 (char *) "self",(char *) "rc", NULL
31660 };
31661
31662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31664 if (!SWIG_IsOK(res1)) {
31665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31666 }
31667 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31668 if (obj1) {
31669 ecode2 = SWIG_AsVal_int(obj1, &val2);
31670 if (!SWIG_IsOK(ecode2)) {
31671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31672 }
31673 arg2 = static_cast< int >(val2);
31674 }
31675 {
31676 PyThreadState* __tstate = wxPyBeginAllowThreads();
31677 (arg1)->Exit(arg2);
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 resultobj = SWIG_Py_Void();
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31689 PyObject *resultobj = 0;
31690 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31691 bool result;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject *swig_obj[1] ;
31695
31696 if (!args) SWIG_fail;
31697 swig_obj[0] = args;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31701 }
31702 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = (bool)((wxEventLoop const *)arg1)->Pending();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 {
31710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31711 }
31712 return resultobj;
31713 fail:
31714 return NULL;
31715 }
31716
31717
31718 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31719 PyObject *resultobj = 0;
31720 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31721 bool result;
31722 void *argp1 = 0 ;
31723 int res1 = 0 ;
31724 PyObject *swig_obj[1] ;
31725
31726 if (!args) SWIG_fail;
31727 swig_obj[0] = args;
31728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31729 if (!SWIG_IsOK(res1)) {
31730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31731 }
31732 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 result = (bool)(arg1)->Dispatch();
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 {
31740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31741 }
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31749 PyObject *resultobj = 0;
31750 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31751 bool result;
31752 void *argp1 = 0 ;
31753 int res1 = 0 ;
31754 PyObject *swig_obj[1] ;
31755
31756 if (!args) SWIG_fail;
31757 swig_obj[0] = args;
31758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31761 }
31762 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 {
31770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31771 }
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31779 PyObject *resultobj = 0;
31780 wxEventLoop *result = 0 ;
31781
31782 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31783 {
31784 PyThreadState* __tstate = wxPyBeginAllowThreads();
31785 result = (wxEventLoop *)wxEventLoop::GetActive();
31786 wxPyEndAllowThreads(__tstate);
31787 if (PyErr_Occurred()) SWIG_fail;
31788 }
31789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31790 return resultobj;
31791 fail:
31792 return NULL;
31793 }
31794
31795
31796 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31797 PyObject *resultobj = 0;
31798 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31799 void *argp1 = 0 ;
31800 int res1 = 0 ;
31801 PyObject * obj0 = 0 ;
31802 char * kwnames[] = {
31803 (char *) "loop", NULL
31804 };
31805
31806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31808 if (!SWIG_IsOK(res1)) {
31809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31810 }
31811 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 wxEventLoop::SetActive(arg1);
31815 wxPyEndAllowThreads(__tstate);
31816 if (PyErr_Occurred()) SWIG_fail;
31817 }
31818 resultobj = SWIG_Py_Void();
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31826 PyObject *obj;
31827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31828 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31829 return SWIG_Py_Void();
31830 }
31831
31832 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31833 return SWIG_Python_InitShadowInstance(args);
31834 }
31835
31836 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31837 PyObject *resultobj = 0;
31838 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31839 wxEventLoopActivator *result = 0 ;
31840 void *argp1 = 0 ;
31841 int res1 = 0 ;
31842 PyObject * obj0 = 0 ;
31843 char * kwnames[] = {
31844 (char *) "evtLoop", NULL
31845 };
31846
31847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31849 if (!SWIG_IsOK(res1)) {
31850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31851 }
31852 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31853 {
31854 PyThreadState* __tstate = wxPyBeginAllowThreads();
31855 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31856 wxPyEndAllowThreads(__tstate);
31857 if (PyErr_Occurred()) SWIG_fail;
31858 }
31859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31860 return resultobj;
31861 fail:
31862 return NULL;
31863 }
31864
31865
31866 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31867 PyObject *resultobj = 0;
31868 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 PyObject *swig_obj[1] ;
31872
31873 if (!args) SWIG_fail;
31874 swig_obj[0] = args;
31875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31878 }
31879 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 delete arg1;
31883
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 resultobj = SWIG_Py_Void();
31888 return resultobj;
31889 fail:
31890 return NULL;
31891 }
31892
31893
31894 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31895 PyObject *obj;
31896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31897 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31898 return SWIG_Py_Void();
31899 }
31900
31901 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31902 return SWIG_Python_InitShadowInstance(args);
31903 }
31904
31905 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31906 PyObject *resultobj = 0;
31907 int arg1 = (int) 0 ;
31908 int arg2 = (int) 0 ;
31909 int arg3 = (int) 0 ;
31910 wxAcceleratorEntry *result = 0 ;
31911 int val1 ;
31912 int ecode1 = 0 ;
31913 int val2 ;
31914 int ecode2 = 0 ;
31915 int val3 ;
31916 int ecode3 = 0 ;
31917 PyObject * obj0 = 0 ;
31918 PyObject * obj1 = 0 ;
31919 PyObject * obj2 = 0 ;
31920 char * kwnames[] = {
31921 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31922 };
31923
31924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31925 if (obj0) {
31926 ecode1 = SWIG_AsVal_int(obj0, &val1);
31927 if (!SWIG_IsOK(ecode1)) {
31928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31929 }
31930 arg1 = static_cast< int >(val1);
31931 }
31932 if (obj1) {
31933 ecode2 = SWIG_AsVal_int(obj1, &val2);
31934 if (!SWIG_IsOK(ecode2)) {
31935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31936 }
31937 arg2 = static_cast< int >(val2);
31938 }
31939 if (obj2) {
31940 ecode3 = SWIG_AsVal_int(obj2, &val3);
31941 if (!SWIG_IsOK(ecode3)) {
31942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31943 }
31944 arg3 = static_cast< int >(val3);
31945 }
31946 {
31947 PyThreadState* __tstate = wxPyBeginAllowThreads();
31948 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31949 wxPyEndAllowThreads(__tstate);
31950 if (PyErr_Occurred()) SWIG_fail;
31951 }
31952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31953 return resultobj;
31954 fail:
31955 return NULL;
31956 }
31957
31958
31959 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31960 PyObject *resultobj = 0;
31961 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31962 void *argp1 = 0 ;
31963 int res1 = 0 ;
31964 PyObject *swig_obj[1] ;
31965
31966 if (!args) SWIG_fail;
31967 swig_obj[0] = args;
31968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31969 if (!SWIG_IsOK(res1)) {
31970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31971 }
31972 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 delete arg1;
31976
31977 wxPyEndAllowThreads(__tstate);
31978 if (PyErr_Occurred()) SWIG_fail;
31979 }
31980 resultobj = SWIG_Py_Void();
31981 return resultobj;
31982 fail:
31983 return NULL;
31984 }
31985
31986
31987 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj = 0;
31989 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31990 int arg2 ;
31991 int arg3 ;
31992 int arg4 ;
31993 void *argp1 = 0 ;
31994 int res1 = 0 ;
31995 int val2 ;
31996 int ecode2 = 0 ;
31997 int val3 ;
31998 int ecode3 = 0 ;
31999 int val4 ;
32000 int ecode4 = 0 ;
32001 PyObject * obj0 = 0 ;
32002 PyObject * obj1 = 0 ;
32003 PyObject * obj2 = 0 ;
32004 PyObject * obj3 = 0 ;
32005 char * kwnames[] = {
32006 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32007 };
32008
32009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32011 if (!SWIG_IsOK(res1)) {
32012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32013 }
32014 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32015 ecode2 = SWIG_AsVal_int(obj1, &val2);
32016 if (!SWIG_IsOK(ecode2)) {
32017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32018 }
32019 arg2 = static_cast< int >(val2);
32020 ecode3 = SWIG_AsVal_int(obj2, &val3);
32021 if (!SWIG_IsOK(ecode3)) {
32022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32023 }
32024 arg3 = static_cast< int >(val3);
32025 ecode4 = SWIG_AsVal_int(obj3, &val4);
32026 if (!SWIG_IsOK(ecode4)) {
32027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32028 }
32029 arg4 = static_cast< int >(val4);
32030 {
32031 PyThreadState* __tstate = wxPyBeginAllowThreads();
32032 (arg1)->Set(arg2,arg3,arg4);
32033 wxPyEndAllowThreads(__tstate);
32034 if (PyErr_Occurred()) SWIG_fail;
32035 }
32036 resultobj = SWIG_Py_Void();
32037 return resultobj;
32038 fail:
32039 return NULL;
32040 }
32041
32042
32043 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32044 PyObject *resultobj = 0;
32045 wxString *arg1 = 0 ;
32046 wxAcceleratorEntry *result = 0 ;
32047 bool temp1 = false ;
32048 PyObject * obj0 = 0 ;
32049 char * kwnames[] = {
32050 (char *) "str", NULL
32051 };
32052
32053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32054 {
32055 arg1 = wxString_in_helper(obj0);
32056 if (arg1 == NULL) SWIG_fail;
32057 temp1 = true;
32058 }
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32066 {
32067 if (temp1)
32068 delete arg1;
32069 }
32070 return resultobj;
32071 fail:
32072 {
32073 if (temp1)
32074 delete arg1;
32075 }
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32081 PyObject *resultobj = 0;
32082 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32083 int result;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 PyObject *swig_obj[1] ;
32087
32088 if (!args) SWIG_fail;
32089 swig_obj[0] = args;
32090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32093 }
32094 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 result = (int)(arg1)->GetFlags();
32098 wxPyEndAllowThreads(__tstate);
32099 if (PyErr_Occurred()) SWIG_fail;
32100 }
32101 resultobj = SWIG_From_int(static_cast< int >(result));
32102 return resultobj;
32103 fail:
32104 return NULL;
32105 }
32106
32107
32108 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32109 PyObject *resultobj = 0;
32110 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32111 int result;
32112 void *argp1 = 0 ;
32113 int res1 = 0 ;
32114 PyObject *swig_obj[1] ;
32115
32116 if (!args) SWIG_fail;
32117 swig_obj[0] = args;
32118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32119 if (!SWIG_IsOK(res1)) {
32120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32121 }
32122 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32123 {
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 result = (int)(arg1)->GetKeyCode();
32126 wxPyEndAllowThreads(__tstate);
32127 if (PyErr_Occurred()) SWIG_fail;
32128 }
32129 resultobj = SWIG_From_int(static_cast< int >(result));
32130 return resultobj;
32131 fail:
32132 return NULL;
32133 }
32134
32135
32136 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32137 PyObject *resultobj = 0;
32138 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32139 int result;
32140 void *argp1 = 0 ;
32141 int res1 = 0 ;
32142 PyObject *swig_obj[1] ;
32143
32144 if (!args) SWIG_fail;
32145 swig_obj[0] = args;
32146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32147 if (!SWIG_IsOK(res1)) {
32148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32149 }
32150 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32151 {
32152 PyThreadState* __tstate = wxPyBeginAllowThreads();
32153 result = (int)(arg1)->GetCommand();
32154 wxPyEndAllowThreads(__tstate);
32155 if (PyErr_Occurred()) SWIG_fail;
32156 }
32157 resultobj = SWIG_From_int(static_cast< int >(result));
32158 return resultobj;
32159 fail:
32160 return NULL;
32161 }
32162
32163
32164 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32165 PyObject *resultobj = 0;
32166 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32167 bool result;
32168 void *argp1 = 0 ;
32169 int res1 = 0 ;
32170 PyObject *swig_obj[1] ;
32171
32172 if (!args) SWIG_fail;
32173 swig_obj[0] = args;
32174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32175 if (!SWIG_IsOK(res1)) {
32176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32177 }
32178 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32179 {
32180 PyThreadState* __tstate = wxPyBeginAllowThreads();
32181 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32182 wxPyEndAllowThreads(__tstate);
32183 if (PyErr_Occurred()) SWIG_fail;
32184 }
32185 {
32186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32187 }
32188 return resultobj;
32189 fail:
32190 return NULL;
32191 }
32192
32193
32194 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32195 PyObject *resultobj = 0;
32196 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32197 wxString result;
32198 void *argp1 = 0 ;
32199 int res1 = 0 ;
32200 PyObject *swig_obj[1] ;
32201
32202 if (!args) SWIG_fail;
32203 swig_obj[0] = args;
32204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32205 if (!SWIG_IsOK(res1)) {
32206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32207 }
32208 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32209 {
32210 PyThreadState* __tstate = wxPyBeginAllowThreads();
32211 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32212 wxPyEndAllowThreads(__tstate);
32213 if (PyErr_Occurred()) SWIG_fail;
32214 }
32215 {
32216 #if wxUSE_UNICODE
32217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32218 #else
32219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32220 #endif
32221 }
32222 return resultobj;
32223 fail:
32224 return NULL;
32225 }
32226
32227
32228 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32229 PyObject *resultobj = 0;
32230 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32231 wxString *arg2 = 0 ;
32232 bool result;
32233 void *argp1 = 0 ;
32234 int res1 = 0 ;
32235 bool temp2 = false ;
32236 PyObject * obj0 = 0 ;
32237 PyObject * obj1 = 0 ;
32238 char * kwnames[] = {
32239 (char *) "self",(char *) "str", NULL
32240 };
32241
32242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32244 if (!SWIG_IsOK(res1)) {
32245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32246 }
32247 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32248 {
32249 arg2 = wxString_in_helper(obj1);
32250 if (arg2 == NULL) SWIG_fail;
32251 temp2 = true;
32252 }
32253 {
32254 PyThreadState* __tstate = wxPyBeginAllowThreads();
32255 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32256 wxPyEndAllowThreads(__tstate);
32257 if (PyErr_Occurred()) SWIG_fail;
32258 }
32259 {
32260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32261 }
32262 {
32263 if (temp2)
32264 delete arg2;
32265 }
32266 return resultobj;
32267 fail:
32268 {
32269 if (temp2)
32270 delete arg2;
32271 }
32272 return NULL;
32273 }
32274
32275
32276 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32277 PyObject *obj;
32278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32279 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32280 return SWIG_Py_Void();
32281 }
32282
32283 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32284 return SWIG_Python_InitShadowInstance(args);
32285 }
32286
32287 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32288 PyObject *resultobj = 0;
32289 int arg1 ;
32290 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32291 wxAcceleratorTable *result = 0 ;
32292 PyObject * obj0 = 0 ;
32293 char * kwnames[] = {
32294 (char *) "n", NULL
32295 };
32296
32297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32298 {
32299 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32300 if (arg2) arg1 = PyList_Size(obj0);
32301 else arg1 = 0;
32302 }
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32310 return resultobj;
32311 fail:
32312 return NULL;
32313 }
32314
32315
32316 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32317 PyObject *resultobj = 0;
32318 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32319 void *argp1 = 0 ;
32320 int res1 = 0 ;
32321 PyObject *swig_obj[1] ;
32322
32323 if (!args) SWIG_fail;
32324 swig_obj[0] = args;
32325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32326 if (!SWIG_IsOK(res1)) {
32327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32328 }
32329 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32330 {
32331 PyThreadState* __tstate = wxPyBeginAllowThreads();
32332 delete arg1;
32333
32334 wxPyEndAllowThreads(__tstate);
32335 if (PyErr_Occurred()) SWIG_fail;
32336 }
32337 resultobj = SWIG_Py_Void();
32338 return resultobj;
32339 fail:
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *resultobj = 0;
32346 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32347 bool result;
32348 void *argp1 = 0 ;
32349 int res1 = 0 ;
32350 PyObject *swig_obj[1] ;
32351
32352 if (!args) SWIG_fail;
32353 swig_obj[0] = args;
32354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32355 if (!SWIG_IsOK(res1)) {
32356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32357 }
32358 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32359 {
32360 PyThreadState* __tstate = wxPyBeginAllowThreads();
32361 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 {
32366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32367 }
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32375 PyObject *obj;
32376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32377 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32378 return SWIG_Py_Void();
32379 }
32380
32381 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32382 return SWIG_Python_InitShadowInstance(args);
32383 }
32384
32385 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32386 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32387 return 1;
32388 }
32389
32390
32391 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32392 PyObject *pyobj = 0;
32393
32394 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32395 return pyobj;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32400 PyObject *resultobj = 0;
32401 wxString *arg1 = 0 ;
32402 wxAcceleratorEntry *result = 0 ;
32403 bool temp1 = false ;
32404 PyObject * obj0 = 0 ;
32405 char * kwnames[] = {
32406 (char *) "label", NULL
32407 };
32408
32409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32410 {
32411 arg1 = wxString_in_helper(obj0);
32412 if (arg1 == NULL) SWIG_fail;
32413 temp1 = true;
32414 }
32415 {
32416 PyThreadState* __tstate = wxPyBeginAllowThreads();
32417 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32418 wxPyEndAllowThreads(__tstate);
32419 if (PyErr_Occurred()) SWIG_fail;
32420 }
32421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32422 {
32423 if (temp1)
32424 delete arg1;
32425 }
32426 return resultobj;
32427 fail:
32428 {
32429 if (temp1)
32430 delete arg1;
32431 }
32432 return NULL;
32433 }
32434
32435
32436 SWIGINTERN int PanelNameStr_set(PyObject *) {
32437 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32438 return 1;
32439 }
32440
32441
32442 SWIGINTERN PyObject *PanelNameStr_get(void) {
32443 PyObject *pyobj = 0;
32444
32445 {
32446 #if wxUSE_UNICODE
32447 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32448 #else
32449 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32450 #endif
32451 }
32452 return pyobj;
32453 }
32454
32455
32456 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32457 PyObject *resultobj = 0;
32458 wxVisualAttributes *result = 0 ;
32459
32460 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32461 {
32462 PyThreadState* __tstate = wxPyBeginAllowThreads();
32463 result = (wxVisualAttributes *)new_wxVisualAttributes();
32464 wxPyEndAllowThreads(__tstate);
32465 if (PyErr_Occurred()) SWIG_fail;
32466 }
32467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32468 return resultobj;
32469 fail:
32470 return NULL;
32471 }
32472
32473
32474 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32475 PyObject *resultobj = 0;
32476 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32477 void *argp1 = 0 ;
32478 int res1 = 0 ;
32479 PyObject *swig_obj[1] ;
32480
32481 if (!args) SWIG_fail;
32482 swig_obj[0] = args;
32483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32486 }
32487 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32488 {
32489 PyThreadState* __tstate = wxPyBeginAllowThreads();
32490 delete_wxVisualAttributes(arg1);
32491
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 resultobj = SWIG_Py_Void();
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32503 PyObject *resultobj = 0;
32504 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32505 wxFont *arg2 = (wxFont *) 0 ;
32506 void *argp1 = 0 ;
32507 int res1 = 0 ;
32508 void *argp2 = 0 ;
32509 int res2 = 0 ;
32510 PyObject *swig_obj[2] ;
32511
32512 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32514 if (!SWIG_IsOK(res1)) {
32515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32516 }
32517 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32518 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32519 if (!SWIG_IsOK(res2)) {
32520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32521 }
32522 arg2 = reinterpret_cast< wxFont * >(argp2);
32523 if (arg1) (arg1)->font = *arg2;
32524
32525 resultobj = SWIG_Py_Void();
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32533 PyObject *resultobj = 0;
32534 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32535 wxFont *result = 0 ;
32536 void *argp1 = 0 ;
32537 int res1 = 0 ;
32538 PyObject *swig_obj[1] ;
32539
32540 if (!args) SWIG_fail;
32541 swig_obj[0] = args;
32542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32543 if (!SWIG_IsOK(res1)) {
32544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32545 }
32546 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32547 result = (wxFont *)& ((arg1)->font);
32548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32549 return resultobj;
32550 fail:
32551 return NULL;
32552 }
32553
32554
32555 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32556 PyObject *resultobj = 0;
32557 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32558 wxColour *arg2 = (wxColour *) 0 ;
32559 void *argp1 = 0 ;
32560 int res1 = 0 ;
32561 void *argp2 = 0 ;
32562 int res2 = 0 ;
32563 PyObject *swig_obj[2] ;
32564
32565 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32569 }
32570 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32571 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32572 if (!SWIG_IsOK(res2)) {
32573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32574 }
32575 arg2 = reinterpret_cast< wxColour * >(argp2);
32576 if (arg1) (arg1)->colFg = *arg2;
32577
32578 resultobj = SWIG_Py_Void();
32579 return resultobj;
32580 fail:
32581 return NULL;
32582 }
32583
32584
32585 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32586 PyObject *resultobj = 0;
32587 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32588 wxColour *result = 0 ;
32589 void *argp1 = 0 ;
32590 int res1 = 0 ;
32591 PyObject *swig_obj[1] ;
32592
32593 if (!args) SWIG_fail;
32594 swig_obj[0] = args;
32595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32596 if (!SWIG_IsOK(res1)) {
32597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32598 }
32599 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32600 result = (wxColour *)& ((arg1)->colFg);
32601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32602 return resultobj;
32603 fail:
32604 return NULL;
32605 }
32606
32607
32608 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32609 PyObject *resultobj = 0;
32610 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32611 wxColour *arg2 = (wxColour *) 0 ;
32612 void *argp1 = 0 ;
32613 int res1 = 0 ;
32614 void *argp2 = 0 ;
32615 int res2 = 0 ;
32616 PyObject *swig_obj[2] ;
32617
32618 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32620 if (!SWIG_IsOK(res1)) {
32621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32622 }
32623 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32624 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32625 if (!SWIG_IsOK(res2)) {
32626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32627 }
32628 arg2 = reinterpret_cast< wxColour * >(argp2);
32629 if (arg1) (arg1)->colBg = *arg2;
32630
32631 resultobj = SWIG_Py_Void();
32632 return resultobj;
32633 fail:
32634 return NULL;
32635 }
32636
32637
32638 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32639 PyObject *resultobj = 0;
32640 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32641 wxColour *result = 0 ;
32642 void *argp1 = 0 ;
32643 int res1 = 0 ;
32644 PyObject *swig_obj[1] ;
32645
32646 if (!args) SWIG_fail;
32647 swig_obj[0] = args;
32648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32649 if (!SWIG_IsOK(res1)) {
32650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32651 }
32652 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32653 result = (wxColour *)& ((arg1)->colBg);
32654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32662 PyObject *obj;
32663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32664 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32665 return SWIG_Py_Void();
32666 }
32667
32668 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32669 return SWIG_Python_InitShadowInstance(args);
32670 }
32671
32672 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32673 PyObject *resultobj = 0;
32674 wxWindow *arg1 = (wxWindow *) 0 ;
32675 int arg2 = (int) (int)-1 ;
32676 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32677 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32678 wxSize const &arg4_defvalue = wxDefaultSize ;
32679 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32680 long arg5 = (long) 0 ;
32681 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32682 wxString *arg6 = (wxString *) &arg6_defvalue ;
32683 wxWindow *result = 0 ;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 int val2 ;
32687 int ecode2 = 0 ;
32688 wxPoint temp3 ;
32689 wxSize temp4 ;
32690 long val5 ;
32691 int ecode5 = 0 ;
32692 bool temp6 = false ;
32693 PyObject * obj0 = 0 ;
32694 PyObject * obj1 = 0 ;
32695 PyObject * obj2 = 0 ;
32696 PyObject * obj3 = 0 ;
32697 PyObject * obj4 = 0 ;
32698 PyObject * obj5 = 0 ;
32699 char * kwnames[] = {
32700 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32701 };
32702
32703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32705 if (!SWIG_IsOK(res1)) {
32706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32707 }
32708 arg1 = reinterpret_cast< wxWindow * >(argp1);
32709 if (obj1) {
32710 ecode2 = SWIG_AsVal_int(obj1, &val2);
32711 if (!SWIG_IsOK(ecode2)) {
32712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32713 }
32714 arg2 = static_cast< int >(val2);
32715 }
32716 if (obj2) {
32717 {
32718 arg3 = &temp3;
32719 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32720 }
32721 }
32722 if (obj3) {
32723 {
32724 arg4 = &temp4;
32725 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32726 }
32727 }
32728 if (obj4) {
32729 ecode5 = SWIG_AsVal_long(obj4, &val5);
32730 if (!SWIG_IsOK(ecode5)) {
32731 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32732 }
32733 arg5 = static_cast< long >(val5);
32734 }
32735 if (obj5) {
32736 {
32737 arg6 = wxString_in_helper(obj5);
32738 if (arg6 == NULL) SWIG_fail;
32739 temp6 = true;
32740 }
32741 }
32742 {
32743 if (!wxPyCheckForApp()) SWIG_fail;
32744 PyThreadState* __tstate = wxPyBeginAllowThreads();
32745 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32746 wxPyEndAllowThreads(__tstate);
32747 if (PyErr_Occurred()) SWIG_fail;
32748 }
32749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32750 {
32751 if (temp6)
32752 delete arg6;
32753 }
32754 return resultobj;
32755 fail:
32756 {
32757 if (temp6)
32758 delete arg6;
32759 }
32760 return NULL;
32761 }
32762
32763
32764 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32765 PyObject *resultobj = 0;
32766 wxWindow *result = 0 ;
32767
32768 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32769 {
32770 if (!wxPyCheckForApp()) SWIG_fail;
32771 PyThreadState* __tstate = wxPyBeginAllowThreads();
32772 result = (wxWindow *)new wxWindow();
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32777 return resultobj;
32778 fail:
32779 return NULL;
32780 }
32781
32782
32783 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32784 PyObject *resultobj = 0;
32785 wxWindow *arg1 = (wxWindow *) 0 ;
32786 wxWindow *arg2 = (wxWindow *) 0 ;
32787 int arg3 = (int) (int)-1 ;
32788 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32789 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32790 wxSize const &arg5_defvalue = wxDefaultSize ;
32791 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32792 long arg6 = (long) 0 ;
32793 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32794 wxString *arg7 = (wxString *) &arg7_defvalue ;
32795 bool result;
32796 void *argp1 = 0 ;
32797 int res1 = 0 ;
32798 void *argp2 = 0 ;
32799 int res2 = 0 ;
32800 int val3 ;
32801 int ecode3 = 0 ;
32802 wxPoint temp4 ;
32803 wxSize temp5 ;
32804 long val6 ;
32805 int ecode6 = 0 ;
32806 bool temp7 = false ;
32807 PyObject * obj0 = 0 ;
32808 PyObject * obj1 = 0 ;
32809 PyObject * obj2 = 0 ;
32810 PyObject * obj3 = 0 ;
32811 PyObject * obj4 = 0 ;
32812 PyObject * obj5 = 0 ;
32813 PyObject * obj6 = 0 ;
32814 char * kwnames[] = {
32815 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32816 };
32817
32818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32822 }
32823 arg1 = reinterpret_cast< wxWindow * >(argp1);
32824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32825 if (!SWIG_IsOK(res2)) {
32826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32827 }
32828 arg2 = reinterpret_cast< wxWindow * >(argp2);
32829 if (obj2) {
32830 ecode3 = SWIG_AsVal_int(obj2, &val3);
32831 if (!SWIG_IsOK(ecode3)) {
32832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32833 }
32834 arg3 = static_cast< int >(val3);
32835 }
32836 if (obj3) {
32837 {
32838 arg4 = &temp4;
32839 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32840 }
32841 }
32842 if (obj4) {
32843 {
32844 arg5 = &temp5;
32845 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32846 }
32847 }
32848 if (obj5) {
32849 ecode6 = SWIG_AsVal_long(obj5, &val6);
32850 if (!SWIG_IsOK(ecode6)) {
32851 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32852 }
32853 arg6 = static_cast< long >(val6);
32854 }
32855 if (obj6) {
32856 {
32857 arg7 = wxString_in_helper(obj6);
32858 if (arg7 == NULL) SWIG_fail;
32859 temp7 = true;
32860 }
32861 }
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 {
32869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32870 }
32871 {
32872 if (temp7)
32873 delete arg7;
32874 }
32875 return resultobj;
32876 fail:
32877 {
32878 if (temp7)
32879 delete arg7;
32880 }
32881 return NULL;
32882 }
32883
32884
32885 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32886 PyObject *resultobj = 0;
32887 wxWindow *arg1 = (wxWindow *) 0 ;
32888 bool arg2 = (bool) false ;
32889 bool result;
32890 void *argp1 = 0 ;
32891 int res1 = 0 ;
32892 bool val2 ;
32893 int ecode2 = 0 ;
32894 PyObject * obj0 = 0 ;
32895 PyObject * obj1 = 0 ;
32896 char * kwnames[] = {
32897 (char *) "self",(char *) "force", NULL
32898 };
32899
32900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32902 if (!SWIG_IsOK(res1)) {
32903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32904 }
32905 arg1 = reinterpret_cast< wxWindow * >(argp1);
32906 if (obj1) {
32907 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32908 if (!SWIG_IsOK(ecode2)) {
32909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32910 }
32911 arg2 = static_cast< bool >(val2);
32912 }
32913 {
32914 PyThreadState* __tstate = wxPyBeginAllowThreads();
32915 result = (bool)(arg1)->Close(arg2);
32916 wxPyEndAllowThreads(__tstate);
32917 if (PyErr_Occurred()) SWIG_fail;
32918 }
32919 {
32920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32921 }
32922 return resultobj;
32923 fail:
32924 return NULL;
32925 }
32926
32927
32928 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32929 PyObject *resultobj = 0;
32930 wxWindow *arg1 = (wxWindow *) 0 ;
32931 bool result;
32932 void *argp1 = 0 ;
32933 int res1 = 0 ;
32934 PyObject *swig_obj[1] ;
32935
32936 if (!args) SWIG_fail;
32937 swig_obj[0] = args;
32938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32939 if (!SWIG_IsOK(res1)) {
32940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32941 }
32942 arg1 = reinterpret_cast< wxWindow * >(argp1);
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 result = (bool)(arg1)->Destroy();
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 {
32950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32951 }
32952 return resultobj;
32953 fail:
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32959 PyObject *resultobj = 0;
32960 wxWindow *arg1 = (wxWindow *) 0 ;
32961 bool result;
32962 void *argp1 = 0 ;
32963 int res1 = 0 ;
32964 PyObject *swig_obj[1] ;
32965
32966 if (!args) SWIG_fail;
32967 swig_obj[0] = args;
32968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32969 if (!SWIG_IsOK(res1)) {
32970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32971 }
32972 arg1 = reinterpret_cast< wxWindow * >(argp1);
32973 {
32974 PyThreadState* __tstate = wxPyBeginAllowThreads();
32975 result = (bool)(arg1)->DestroyChildren();
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 {
32980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32981 }
32982 return resultobj;
32983 fail:
32984 return NULL;
32985 }
32986
32987
32988 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32989 PyObject *resultobj = 0;
32990 wxWindow *arg1 = (wxWindow *) 0 ;
32991 bool result;
32992 void *argp1 = 0 ;
32993 int res1 = 0 ;
32994 PyObject *swig_obj[1] ;
32995
32996 if (!args) SWIG_fail;
32997 swig_obj[0] = args;
32998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32999 if (!SWIG_IsOK(res1)) {
33000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33001 }
33002 arg1 = reinterpret_cast< wxWindow * >(argp1);
33003 {
33004 PyThreadState* __tstate = wxPyBeginAllowThreads();
33005 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33006 wxPyEndAllowThreads(__tstate);
33007 if (PyErr_Occurred()) SWIG_fail;
33008 }
33009 {
33010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33011 }
33012 return resultobj;
33013 fail:
33014 return NULL;
33015 }
33016
33017
33018 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33019 PyObject *resultobj = 0;
33020 wxWindow *arg1 = (wxWindow *) 0 ;
33021 wxString *arg2 = 0 ;
33022 void *argp1 = 0 ;
33023 int res1 = 0 ;
33024 bool temp2 = false ;
33025 PyObject * obj0 = 0 ;
33026 PyObject * obj1 = 0 ;
33027 char * kwnames[] = {
33028 (char *) "self",(char *) "label", NULL
33029 };
33030
33031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33035 }
33036 arg1 = reinterpret_cast< wxWindow * >(argp1);
33037 {
33038 arg2 = wxString_in_helper(obj1);
33039 if (arg2 == NULL) SWIG_fail;
33040 temp2 = true;
33041 }
33042 {
33043 PyThreadState* __tstate = wxPyBeginAllowThreads();
33044 (arg1)->SetLabel((wxString const &)*arg2);
33045 wxPyEndAllowThreads(__tstate);
33046 if (PyErr_Occurred()) SWIG_fail;
33047 }
33048 resultobj = SWIG_Py_Void();
33049 {
33050 if (temp2)
33051 delete arg2;
33052 }
33053 return resultobj;
33054 fail:
33055 {
33056 if (temp2)
33057 delete arg2;
33058 }
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33064 PyObject *resultobj = 0;
33065 wxWindow *arg1 = (wxWindow *) 0 ;
33066 wxString result;
33067 void *argp1 = 0 ;
33068 int res1 = 0 ;
33069 PyObject *swig_obj[1] ;
33070
33071 if (!args) SWIG_fail;
33072 swig_obj[0] = args;
33073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33074 if (!SWIG_IsOK(res1)) {
33075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33076 }
33077 arg1 = reinterpret_cast< wxWindow * >(argp1);
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 result = ((wxWindow const *)arg1)->GetLabel();
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 {
33085 #if wxUSE_UNICODE
33086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33087 #else
33088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33089 #endif
33090 }
33091 return resultobj;
33092 fail:
33093 return NULL;
33094 }
33095
33096
33097 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33098 PyObject *resultobj = 0;
33099 wxWindow *arg1 = (wxWindow *) 0 ;
33100 wxString *arg2 = 0 ;
33101 void *argp1 = 0 ;
33102 int res1 = 0 ;
33103 bool temp2 = false ;
33104 PyObject * obj0 = 0 ;
33105 PyObject * obj1 = 0 ;
33106 char * kwnames[] = {
33107 (char *) "self",(char *) "name", NULL
33108 };
33109
33110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33112 if (!SWIG_IsOK(res1)) {
33113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33114 }
33115 arg1 = reinterpret_cast< wxWindow * >(argp1);
33116 {
33117 arg2 = wxString_in_helper(obj1);
33118 if (arg2 == NULL) SWIG_fail;
33119 temp2 = true;
33120 }
33121 {
33122 PyThreadState* __tstate = wxPyBeginAllowThreads();
33123 (arg1)->SetName((wxString const &)*arg2);
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 resultobj = SWIG_Py_Void();
33128 {
33129 if (temp2)
33130 delete arg2;
33131 }
33132 return resultobj;
33133 fail:
33134 {
33135 if (temp2)
33136 delete arg2;
33137 }
33138 return NULL;
33139 }
33140
33141
33142 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33143 PyObject *resultobj = 0;
33144 wxWindow *arg1 = (wxWindow *) 0 ;
33145 wxString result;
33146 void *argp1 = 0 ;
33147 int res1 = 0 ;
33148 PyObject *swig_obj[1] ;
33149
33150 if (!args) SWIG_fail;
33151 swig_obj[0] = args;
33152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33153 if (!SWIG_IsOK(res1)) {
33154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33155 }
33156 arg1 = reinterpret_cast< wxWindow * >(argp1);
33157 {
33158 PyThreadState* __tstate = wxPyBeginAllowThreads();
33159 result = ((wxWindow const *)arg1)->GetName();
33160 wxPyEndAllowThreads(__tstate);
33161 if (PyErr_Occurred()) SWIG_fail;
33162 }
33163 {
33164 #if wxUSE_UNICODE
33165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33166 #else
33167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33168 #endif
33169 }
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33177 PyObject *resultobj = 0;
33178 wxWindow *arg1 = (wxWindow *) 0 ;
33179 wxWindowVariant arg2 ;
33180 void *argp1 = 0 ;
33181 int res1 = 0 ;
33182 int val2 ;
33183 int ecode2 = 0 ;
33184 PyObject * obj0 = 0 ;
33185 PyObject * obj1 = 0 ;
33186 char * kwnames[] = {
33187 (char *) "self",(char *) "variant", NULL
33188 };
33189
33190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res1)) {
33193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33194 }
33195 arg1 = reinterpret_cast< wxWindow * >(argp1);
33196 ecode2 = SWIG_AsVal_int(obj1, &val2);
33197 if (!SWIG_IsOK(ecode2)) {
33198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33199 }
33200 arg2 = static_cast< wxWindowVariant >(val2);
33201 {
33202 PyThreadState* __tstate = wxPyBeginAllowThreads();
33203 (arg1)->SetWindowVariant(arg2);
33204 wxPyEndAllowThreads(__tstate);
33205 if (PyErr_Occurred()) SWIG_fail;
33206 }
33207 resultobj = SWIG_Py_Void();
33208 return resultobj;
33209 fail:
33210 return NULL;
33211 }
33212
33213
33214 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33215 PyObject *resultobj = 0;
33216 wxWindow *arg1 = (wxWindow *) 0 ;
33217 wxWindowVariant result;
33218 void *argp1 = 0 ;
33219 int res1 = 0 ;
33220 PyObject *swig_obj[1] ;
33221
33222 if (!args) SWIG_fail;
33223 swig_obj[0] = args;
33224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33227 }
33228 arg1 = reinterpret_cast< wxWindow * >(argp1);
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 resultobj = SWIG_From_int(static_cast< int >(result));
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33243 PyObject *resultobj = 0;
33244 wxWindow *arg1 = (wxWindow *) 0 ;
33245 int arg2 ;
33246 void *argp1 = 0 ;
33247 int res1 = 0 ;
33248 int val2 ;
33249 int ecode2 = 0 ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 char * kwnames[] = {
33253 (char *) "self",(char *) "winid", NULL
33254 };
33255
33256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33258 if (!SWIG_IsOK(res1)) {
33259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33260 }
33261 arg1 = reinterpret_cast< wxWindow * >(argp1);
33262 ecode2 = SWIG_AsVal_int(obj1, &val2);
33263 if (!SWIG_IsOK(ecode2)) {
33264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33265 }
33266 arg2 = static_cast< int >(val2);
33267 {
33268 PyThreadState* __tstate = wxPyBeginAllowThreads();
33269 (arg1)->SetId(arg2);
33270 wxPyEndAllowThreads(__tstate);
33271 if (PyErr_Occurred()) SWIG_fail;
33272 }
33273 resultobj = SWIG_Py_Void();
33274 return resultobj;
33275 fail:
33276 return NULL;
33277 }
33278
33279
33280 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33281 PyObject *resultobj = 0;
33282 wxWindow *arg1 = (wxWindow *) 0 ;
33283 int result;
33284 void *argp1 = 0 ;
33285 int res1 = 0 ;
33286 PyObject *swig_obj[1] ;
33287
33288 if (!args) SWIG_fail;
33289 swig_obj[0] = args;
33290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33291 if (!SWIG_IsOK(res1)) {
33292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33293 }
33294 arg1 = reinterpret_cast< wxWindow * >(argp1);
33295 {
33296 PyThreadState* __tstate = wxPyBeginAllowThreads();
33297 result = (int)((wxWindow const *)arg1)->GetId();
33298 wxPyEndAllowThreads(__tstate);
33299 if (PyErr_Occurred()) SWIG_fail;
33300 }
33301 resultobj = SWIG_From_int(static_cast< int >(result));
33302 return resultobj;
33303 fail:
33304 return NULL;
33305 }
33306
33307
33308 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33309 PyObject *resultobj = 0;
33310 int result;
33311
33312 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 result = (int)wxWindow::NewControlId();
33316 wxPyEndAllowThreads(__tstate);
33317 if (PyErr_Occurred()) SWIG_fail;
33318 }
33319 resultobj = SWIG_From_int(static_cast< int >(result));
33320 return resultobj;
33321 fail:
33322 return NULL;
33323 }
33324
33325
33326 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33327 PyObject *resultobj = 0;
33328 int arg1 ;
33329 int result;
33330 int val1 ;
33331 int ecode1 = 0 ;
33332 PyObject * obj0 = 0 ;
33333 char * kwnames[] = {
33334 (char *) "winid", NULL
33335 };
33336
33337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33338 ecode1 = SWIG_AsVal_int(obj0, &val1);
33339 if (!SWIG_IsOK(ecode1)) {
33340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33341 }
33342 arg1 = static_cast< int >(val1);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (int)wxWindow::NextControlId(arg1);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 resultobj = SWIG_From_int(static_cast< int >(result));
33350 return resultobj;
33351 fail:
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33357 PyObject *resultobj = 0;
33358 int arg1 ;
33359 int result;
33360 int val1 ;
33361 int ecode1 = 0 ;
33362 PyObject * obj0 = 0 ;
33363 char * kwnames[] = {
33364 (char *) "winid", NULL
33365 };
33366
33367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33368 ecode1 = SWIG_AsVal_int(obj0, &val1);
33369 if (!SWIG_IsOK(ecode1)) {
33370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33371 }
33372 arg1 = static_cast< int >(val1);
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 result = (int)wxWindow::PrevControlId(arg1);
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 resultobj = SWIG_From_int(static_cast< int >(result));
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33387 PyObject *resultobj = 0;
33388 wxWindow *arg1 = (wxWindow *) 0 ;
33389 wxLayoutDirection result;
33390 void *argp1 = 0 ;
33391 int res1 = 0 ;
33392 PyObject *swig_obj[1] ;
33393
33394 if (!args) SWIG_fail;
33395 swig_obj[0] = args;
33396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33397 if (!SWIG_IsOK(res1)) {
33398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33399 }
33400 arg1 = reinterpret_cast< wxWindow * >(argp1);
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33404 wxPyEndAllowThreads(__tstate);
33405 if (PyErr_Occurred()) SWIG_fail;
33406 }
33407 resultobj = SWIG_From_int(static_cast< int >(result));
33408 return resultobj;
33409 fail:
33410 return NULL;
33411 }
33412
33413
33414 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33415 PyObject *resultobj = 0;
33416 wxWindow *arg1 = (wxWindow *) 0 ;
33417 wxLayoutDirection arg2 ;
33418 void *argp1 = 0 ;
33419 int res1 = 0 ;
33420 int val2 ;
33421 int ecode2 = 0 ;
33422 PyObject * obj0 = 0 ;
33423 PyObject * obj1 = 0 ;
33424 char * kwnames[] = {
33425 (char *) "self",(char *) "dir", NULL
33426 };
33427
33428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33430 if (!SWIG_IsOK(res1)) {
33431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33432 }
33433 arg1 = reinterpret_cast< wxWindow * >(argp1);
33434 ecode2 = SWIG_AsVal_int(obj1, &val2);
33435 if (!SWIG_IsOK(ecode2)) {
33436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33437 }
33438 arg2 = static_cast< wxLayoutDirection >(val2);
33439 {
33440 PyThreadState* __tstate = wxPyBeginAllowThreads();
33441 (arg1)->SetLayoutDirection(arg2);
33442 wxPyEndAllowThreads(__tstate);
33443 if (PyErr_Occurred()) SWIG_fail;
33444 }
33445 resultobj = SWIG_Py_Void();
33446 return resultobj;
33447 fail:
33448 return NULL;
33449 }
33450
33451
33452 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33453 PyObject *resultobj = 0;
33454 wxWindow *arg1 = (wxWindow *) 0 ;
33455 int arg2 ;
33456 int arg3 ;
33457 int arg4 ;
33458 int result;
33459 void *argp1 = 0 ;
33460 int res1 = 0 ;
33461 int val2 ;
33462 int ecode2 = 0 ;
33463 int val3 ;
33464 int ecode3 = 0 ;
33465 int val4 ;
33466 int ecode4 = 0 ;
33467 PyObject * obj0 = 0 ;
33468 PyObject * obj1 = 0 ;
33469 PyObject * obj2 = 0 ;
33470 PyObject * obj3 = 0 ;
33471 char * kwnames[] = {
33472 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33473 };
33474
33475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33477 if (!SWIG_IsOK(res1)) {
33478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33479 }
33480 arg1 = reinterpret_cast< wxWindow * >(argp1);
33481 ecode2 = SWIG_AsVal_int(obj1, &val2);
33482 if (!SWIG_IsOK(ecode2)) {
33483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33484 }
33485 arg2 = static_cast< int >(val2);
33486 ecode3 = SWIG_AsVal_int(obj2, &val3);
33487 if (!SWIG_IsOK(ecode3)) {
33488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33489 }
33490 arg3 = static_cast< int >(val3);
33491 ecode4 = SWIG_AsVal_int(obj3, &val4);
33492 if (!SWIG_IsOK(ecode4)) {
33493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33494 }
33495 arg4 = static_cast< int >(val4);
33496 {
33497 PyThreadState* __tstate = wxPyBeginAllowThreads();
33498 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33499 wxPyEndAllowThreads(__tstate);
33500 if (PyErr_Occurred()) SWIG_fail;
33501 }
33502 resultobj = SWIG_From_int(static_cast< int >(result));
33503 return resultobj;
33504 fail:
33505 return NULL;
33506 }
33507
33508
33509 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33510 PyObject *resultobj = 0;
33511 wxWindow *arg1 = (wxWindow *) 0 ;
33512 wxSize *arg2 = 0 ;
33513 void *argp1 = 0 ;
33514 int res1 = 0 ;
33515 wxSize temp2 ;
33516 PyObject * obj0 = 0 ;
33517 PyObject * obj1 = 0 ;
33518 char * kwnames[] = {
33519 (char *) "self",(char *) "size", NULL
33520 };
33521
33522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33524 if (!SWIG_IsOK(res1)) {
33525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33526 }
33527 arg1 = reinterpret_cast< wxWindow * >(argp1);
33528 {
33529 arg2 = &temp2;
33530 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33531 }
33532 {
33533 PyThreadState* __tstate = wxPyBeginAllowThreads();
33534 (arg1)->SetSize((wxSize const &)*arg2);
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 resultobj = SWIG_Py_Void();
33539 return resultobj;
33540 fail:
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33546 PyObject *resultobj = 0;
33547 wxWindow *arg1 = (wxWindow *) 0 ;
33548 int arg2 ;
33549 int arg3 ;
33550 int arg4 ;
33551 int arg5 ;
33552 int arg6 = (int) wxSIZE_AUTO ;
33553 void *argp1 = 0 ;
33554 int res1 = 0 ;
33555 int val2 ;
33556 int ecode2 = 0 ;
33557 int val3 ;
33558 int ecode3 = 0 ;
33559 int val4 ;
33560 int ecode4 = 0 ;
33561 int val5 ;
33562 int ecode5 = 0 ;
33563 int val6 ;
33564 int ecode6 = 0 ;
33565 PyObject * obj0 = 0 ;
33566 PyObject * obj1 = 0 ;
33567 PyObject * obj2 = 0 ;
33568 PyObject * obj3 = 0 ;
33569 PyObject * obj4 = 0 ;
33570 PyObject * obj5 = 0 ;
33571 char * kwnames[] = {
33572 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33573 };
33574
33575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33577 if (!SWIG_IsOK(res1)) {
33578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33579 }
33580 arg1 = reinterpret_cast< wxWindow * >(argp1);
33581 ecode2 = SWIG_AsVal_int(obj1, &val2);
33582 if (!SWIG_IsOK(ecode2)) {
33583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33584 }
33585 arg2 = static_cast< int >(val2);
33586 ecode3 = SWIG_AsVal_int(obj2, &val3);
33587 if (!SWIG_IsOK(ecode3)) {
33588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33589 }
33590 arg3 = static_cast< int >(val3);
33591 ecode4 = SWIG_AsVal_int(obj3, &val4);
33592 if (!SWIG_IsOK(ecode4)) {
33593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33594 }
33595 arg4 = static_cast< int >(val4);
33596 ecode5 = SWIG_AsVal_int(obj4, &val5);
33597 if (!SWIG_IsOK(ecode5)) {
33598 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33599 }
33600 arg5 = static_cast< int >(val5);
33601 if (obj5) {
33602 ecode6 = SWIG_AsVal_int(obj5, &val6);
33603 if (!SWIG_IsOK(ecode6)) {
33604 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33605 }
33606 arg6 = static_cast< int >(val6);
33607 }
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 resultobj = SWIG_Py_Void();
33615 return resultobj;
33616 fail:
33617 return NULL;
33618 }
33619
33620
33621 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33622 PyObject *resultobj = 0;
33623 wxWindow *arg1 = (wxWindow *) 0 ;
33624 wxRect *arg2 = 0 ;
33625 int arg3 = (int) wxSIZE_AUTO ;
33626 void *argp1 = 0 ;
33627 int res1 = 0 ;
33628 wxRect temp2 ;
33629 int val3 ;
33630 int ecode3 = 0 ;
33631 PyObject * obj0 = 0 ;
33632 PyObject * obj1 = 0 ;
33633 PyObject * obj2 = 0 ;
33634 char * kwnames[] = {
33635 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33636 };
33637
33638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33640 if (!SWIG_IsOK(res1)) {
33641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33642 }
33643 arg1 = reinterpret_cast< wxWindow * >(argp1);
33644 {
33645 arg2 = &temp2;
33646 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33647 }
33648 if (obj2) {
33649 ecode3 = SWIG_AsVal_int(obj2, &val3);
33650 if (!SWIG_IsOK(ecode3)) {
33651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33652 }
33653 arg3 = static_cast< int >(val3);
33654 }
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 resultobj = SWIG_Py_Void();
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj = 0;
33670 wxWindow *arg1 = (wxWindow *) 0 ;
33671 int arg2 ;
33672 int arg3 ;
33673 void *argp1 = 0 ;
33674 int res1 = 0 ;
33675 int val2 ;
33676 int ecode2 = 0 ;
33677 int val3 ;
33678 int ecode3 = 0 ;
33679 PyObject * obj0 = 0 ;
33680 PyObject * obj1 = 0 ;
33681 PyObject * obj2 = 0 ;
33682 char * kwnames[] = {
33683 (char *) "self",(char *) "width",(char *) "height", NULL
33684 };
33685
33686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33690 }
33691 arg1 = reinterpret_cast< wxWindow * >(argp1);
33692 ecode2 = SWIG_AsVal_int(obj1, &val2);
33693 if (!SWIG_IsOK(ecode2)) {
33694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33695 }
33696 arg2 = static_cast< int >(val2);
33697 ecode3 = SWIG_AsVal_int(obj2, &val3);
33698 if (!SWIG_IsOK(ecode3)) {
33699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33700 }
33701 arg3 = static_cast< int >(val3);
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 (arg1)->SetSize(arg2,arg3);
33705 wxPyEndAllowThreads(__tstate);
33706 if (PyErr_Occurred()) SWIG_fail;
33707 }
33708 resultobj = SWIG_Py_Void();
33709 return resultobj;
33710 fail:
33711 return NULL;
33712 }
33713
33714
33715 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33716 PyObject *resultobj = 0;
33717 wxWindow *arg1 = (wxWindow *) 0 ;
33718 wxPoint *arg2 = 0 ;
33719 int arg3 = (int) wxSIZE_USE_EXISTING ;
33720 void *argp1 = 0 ;
33721 int res1 = 0 ;
33722 wxPoint temp2 ;
33723 int val3 ;
33724 int ecode3 = 0 ;
33725 PyObject * obj0 = 0 ;
33726 PyObject * obj1 = 0 ;
33727 PyObject * obj2 = 0 ;
33728 char * kwnames[] = {
33729 (char *) "self",(char *) "pt",(char *) "flags", NULL
33730 };
33731
33732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33734 if (!SWIG_IsOK(res1)) {
33735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33736 }
33737 arg1 = reinterpret_cast< wxWindow * >(argp1);
33738 {
33739 arg2 = &temp2;
33740 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33741 }
33742 if (obj2) {
33743 ecode3 = SWIG_AsVal_int(obj2, &val3);
33744 if (!SWIG_IsOK(ecode3)) {
33745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33746 }
33747 arg3 = static_cast< int >(val3);
33748 }
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 (arg1)->Move((wxPoint const &)*arg2,arg3);
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 resultobj = SWIG_Py_Void();
33756 return resultobj;
33757 fail:
33758 return NULL;
33759 }
33760
33761
33762 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33763 PyObject *resultobj = 0;
33764 wxWindow *arg1 = (wxWindow *) 0 ;
33765 int arg2 ;
33766 int arg3 ;
33767 int arg4 = (int) wxSIZE_USE_EXISTING ;
33768 void *argp1 = 0 ;
33769 int res1 = 0 ;
33770 int val2 ;
33771 int ecode2 = 0 ;
33772 int val3 ;
33773 int ecode3 = 0 ;
33774 int val4 ;
33775 int ecode4 = 0 ;
33776 PyObject * obj0 = 0 ;
33777 PyObject * obj1 = 0 ;
33778 PyObject * obj2 = 0 ;
33779 PyObject * obj3 = 0 ;
33780 char * kwnames[] = {
33781 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33782 };
33783
33784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33786 if (!SWIG_IsOK(res1)) {
33787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33788 }
33789 arg1 = reinterpret_cast< wxWindow * >(argp1);
33790 ecode2 = SWIG_AsVal_int(obj1, &val2);
33791 if (!SWIG_IsOK(ecode2)) {
33792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33793 }
33794 arg2 = static_cast< int >(val2);
33795 ecode3 = SWIG_AsVal_int(obj2, &val3);
33796 if (!SWIG_IsOK(ecode3)) {
33797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33798 }
33799 arg3 = static_cast< int >(val3);
33800 if (obj3) {
33801 ecode4 = SWIG_AsVal_int(obj3, &val4);
33802 if (!SWIG_IsOK(ecode4)) {
33803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33804 }
33805 arg4 = static_cast< int >(val4);
33806 }
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 (arg1)->Move(arg2,arg3,arg4);
33810 wxPyEndAllowThreads(__tstate);
33811 if (PyErr_Occurred()) SWIG_fail;
33812 }
33813 resultobj = SWIG_Py_Void();
33814 return resultobj;
33815 fail:
33816 return NULL;
33817 }
33818
33819
33820 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33821 PyObject *resultobj = 0;
33822 wxWindow *arg1 = (wxWindow *) 0 ;
33823 wxSize const &arg2_defvalue = wxDefaultSize ;
33824 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33825 void *argp1 = 0 ;
33826 int res1 = 0 ;
33827 wxSize temp2 ;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char * kwnames[] = {
33831 (char *) "self",(char *) "size", NULL
33832 };
33833
33834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33836 if (!SWIG_IsOK(res1)) {
33837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33838 }
33839 arg1 = reinterpret_cast< wxWindow * >(argp1);
33840 if (obj1) {
33841 {
33842 arg2 = &temp2;
33843 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33844 }
33845 }
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 (arg1)->SetInitialSize((wxSize const &)*arg2);
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 resultobj = SWIG_Py_Void();
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33860 PyObject *resultobj = 0;
33861 wxWindow *arg1 = (wxWindow *) 0 ;
33862 void *argp1 = 0 ;
33863 int res1 = 0 ;
33864 PyObject *swig_obj[1] ;
33865
33866 if (!args) SWIG_fail;
33867 swig_obj[0] = args;
33868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33869 if (!SWIG_IsOK(res1)) {
33870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33871 }
33872 arg1 = reinterpret_cast< wxWindow * >(argp1);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 (arg1)->Raise();
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 resultobj = SWIG_Py_Void();
33880 return resultobj;
33881 fail:
33882 return NULL;
33883 }
33884
33885
33886 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33887 PyObject *resultobj = 0;
33888 wxWindow *arg1 = (wxWindow *) 0 ;
33889 void *argp1 = 0 ;
33890 int res1 = 0 ;
33891 PyObject *swig_obj[1] ;
33892
33893 if (!args) SWIG_fail;
33894 swig_obj[0] = args;
33895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33896 if (!SWIG_IsOK(res1)) {
33897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33898 }
33899 arg1 = reinterpret_cast< wxWindow * >(argp1);
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 (arg1)->Lower();
33903 wxPyEndAllowThreads(__tstate);
33904 if (PyErr_Occurred()) SWIG_fail;
33905 }
33906 resultobj = SWIG_Py_Void();
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj = 0;
33915 wxWindow *arg1 = (wxWindow *) 0 ;
33916 wxSize *arg2 = 0 ;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 wxSize temp2 ;
33920 PyObject * obj0 = 0 ;
33921 PyObject * obj1 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "size", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 {
33933 arg2 = &temp2;
33934 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33935 }
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 (arg1)->SetClientSize((wxSize const &)*arg2);
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 resultobj = SWIG_Py_Void();
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj = 0;
33951 wxWindow *arg1 = (wxWindow *) 0 ;
33952 int arg2 ;
33953 int arg3 ;
33954 void *argp1 = 0 ;
33955 int res1 = 0 ;
33956 int val2 ;
33957 int ecode2 = 0 ;
33958 int val3 ;
33959 int ecode3 = 0 ;
33960 PyObject * obj0 = 0 ;
33961 PyObject * obj1 = 0 ;
33962 PyObject * obj2 = 0 ;
33963 char * kwnames[] = {
33964 (char *) "self",(char *) "width",(char *) "height", NULL
33965 };
33966
33967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33969 if (!SWIG_IsOK(res1)) {
33970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33971 }
33972 arg1 = reinterpret_cast< wxWindow * >(argp1);
33973 ecode2 = SWIG_AsVal_int(obj1, &val2);
33974 if (!SWIG_IsOK(ecode2)) {
33975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33976 }
33977 arg2 = static_cast< int >(val2);
33978 ecode3 = SWIG_AsVal_int(obj2, &val3);
33979 if (!SWIG_IsOK(ecode3)) {
33980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33981 }
33982 arg3 = static_cast< int >(val3);
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 (arg1)->SetClientSize(arg2,arg3);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_Py_Void();
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 wxWindow *arg1 = (wxWindow *) 0 ;
33999 wxRect *arg2 = 0 ;
34000 void *argp1 = 0 ;
34001 int res1 = 0 ;
34002 wxRect temp2 ;
34003 PyObject * obj0 = 0 ;
34004 PyObject * obj1 = 0 ;
34005 char * kwnames[] = {
34006 (char *) "self",(char *) "rect", NULL
34007 };
34008
34009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34013 }
34014 arg1 = reinterpret_cast< wxWindow * >(argp1);
34015 {
34016 arg2 = &temp2;
34017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34018 }
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 (arg1)->SetClientSize((wxRect const &)*arg2);
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 resultobj = SWIG_Py_Void();
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34033 PyObject *resultobj = 0;
34034 wxWindow *arg1 = (wxWindow *) 0 ;
34035 wxPoint result;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 PyObject *swig_obj[1] ;
34039
34040 if (!args) SWIG_fail;
34041 swig_obj[0] = args;
34042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34043 if (!SWIG_IsOK(res1)) {
34044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34045 }
34046 arg1 = reinterpret_cast< wxWindow * >(argp1);
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 result = ((wxWindow const *)arg1)->GetPosition();
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34061 PyObject *resultobj = 0;
34062 wxWindow *arg1 = (wxWindow *) 0 ;
34063 int *arg2 = (int *) 0 ;
34064 int *arg3 = (int *) 0 ;
34065 void *argp1 = 0 ;
34066 int res1 = 0 ;
34067 int temp2 ;
34068 int res2 = SWIG_TMPOBJ ;
34069 int temp3 ;
34070 int res3 = SWIG_TMPOBJ ;
34071 PyObject *swig_obj[1] ;
34072
34073 arg2 = &temp2;
34074 arg3 = &temp3;
34075 if (!args) SWIG_fail;
34076 swig_obj[0] = args;
34077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34080 }
34081 arg1 = reinterpret_cast< wxWindow * >(argp1);
34082 {
34083 PyThreadState* __tstate = wxPyBeginAllowThreads();
34084 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34085 wxPyEndAllowThreads(__tstate);
34086 if (PyErr_Occurred()) SWIG_fail;
34087 }
34088 resultobj = SWIG_Py_Void();
34089 if (SWIG_IsTmpObj(res2)) {
34090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34091 } else {
34092 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34094 }
34095 if (SWIG_IsTmpObj(res3)) {
34096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34097 } else {
34098 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34100 }
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxPoint result;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 PyObject *swig_obj[1] ;
34114
34115 if (!args) SWIG_fail;
34116 swig_obj[0] = args;
34117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34120 }
34121 arg1 = reinterpret_cast< wxWindow * >(argp1);
34122 {
34123 PyThreadState* __tstate = wxPyBeginAllowThreads();
34124 result = ((wxWindow const *)arg1)->GetScreenPosition();
34125 wxPyEndAllowThreads(__tstate);
34126 if (PyErr_Occurred()) SWIG_fail;
34127 }
34128 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34129 return resultobj;
34130 fail:
34131 return NULL;
34132 }
34133
34134
34135 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34136 PyObject *resultobj = 0;
34137 wxWindow *arg1 = (wxWindow *) 0 ;
34138 int *arg2 = (int *) 0 ;
34139 int *arg3 = (int *) 0 ;
34140 void *argp1 = 0 ;
34141 int res1 = 0 ;
34142 int temp2 ;
34143 int res2 = SWIG_TMPOBJ ;
34144 int temp3 ;
34145 int res3 = SWIG_TMPOBJ ;
34146 PyObject *swig_obj[1] ;
34147
34148 arg2 = &temp2;
34149 arg3 = &temp3;
34150 if (!args) SWIG_fail;
34151 swig_obj[0] = args;
34152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34153 if (!SWIG_IsOK(res1)) {
34154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34155 }
34156 arg1 = reinterpret_cast< wxWindow * >(argp1);
34157 {
34158 PyThreadState* __tstate = wxPyBeginAllowThreads();
34159 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 resultobj = SWIG_Py_Void();
34164 if (SWIG_IsTmpObj(res2)) {
34165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34166 } else {
34167 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34169 }
34170 if (SWIG_IsTmpObj(res3)) {
34171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34172 } else {
34173 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34175 }
34176 return resultobj;
34177 fail:
34178 return NULL;
34179 }
34180
34181
34182 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34183 PyObject *resultobj = 0;
34184 wxWindow *arg1 = (wxWindow *) 0 ;
34185 wxRect result;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 PyObject *swig_obj[1] ;
34189
34190 if (!args) SWIG_fail;
34191 swig_obj[0] = args;
34192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res1)) {
34194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34195 }
34196 arg1 = reinterpret_cast< wxWindow * >(argp1);
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 result = ((wxWindow const *)arg1)->GetScreenRect();
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34211 PyObject *resultobj = 0;
34212 wxWindow *arg1 = (wxWindow *) 0 ;
34213 wxSize result;
34214 void *argp1 = 0 ;
34215 int res1 = 0 ;
34216 PyObject *swig_obj[1] ;
34217
34218 if (!args) SWIG_fail;
34219 swig_obj[0] = args;
34220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 result = ((wxWindow const *)arg1)->GetSize();
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxWindow *arg1 = (wxWindow *) 0 ;
34241 int *arg2 = (int *) 0 ;
34242 int *arg3 = (int *) 0 ;
34243 void *argp1 = 0 ;
34244 int res1 = 0 ;
34245 int temp2 ;
34246 int res2 = SWIG_TMPOBJ ;
34247 int temp3 ;
34248 int res3 = SWIG_TMPOBJ ;
34249 PyObject *swig_obj[1] ;
34250
34251 arg2 = &temp2;
34252 arg3 = &temp3;
34253 if (!args) SWIG_fail;
34254 swig_obj[0] = args;
34255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34256 if (!SWIG_IsOK(res1)) {
34257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34258 }
34259 arg1 = reinterpret_cast< wxWindow * >(argp1);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 resultobj = SWIG_Py_Void();
34267 if (SWIG_IsTmpObj(res2)) {
34268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34269 } else {
34270 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34272 }
34273 if (SWIG_IsTmpObj(res3)) {
34274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34275 } else {
34276 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34278 }
34279 return resultobj;
34280 fail:
34281 return NULL;
34282 }
34283
34284
34285 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34286 PyObject *resultobj = 0;
34287 wxWindow *arg1 = (wxWindow *) 0 ;
34288 wxRect result;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 PyObject *swig_obj[1] ;
34292
34293 if (!args) SWIG_fail;
34294 swig_obj[0] = args;
34295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34296 if (!SWIG_IsOK(res1)) {
34297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34298 }
34299 arg1 = reinterpret_cast< wxWindow * >(argp1);
34300 {
34301 PyThreadState* __tstate = wxPyBeginAllowThreads();
34302 result = ((wxWindow const *)arg1)->GetRect();
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34307 return resultobj;
34308 fail:
34309 return NULL;
34310 }
34311
34312
34313 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34314 PyObject *resultobj = 0;
34315 wxWindow *arg1 = (wxWindow *) 0 ;
34316 wxSize result;
34317 void *argp1 = 0 ;
34318 int res1 = 0 ;
34319 PyObject *swig_obj[1] ;
34320
34321 if (!args) SWIG_fail;
34322 swig_obj[0] = args;
34323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34324 if (!SWIG_IsOK(res1)) {
34325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34326 }
34327 arg1 = reinterpret_cast< wxWindow * >(argp1);
34328 {
34329 PyThreadState* __tstate = wxPyBeginAllowThreads();
34330 result = ((wxWindow const *)arg1)->GetClientSize();
34331 wxPyEndAllowThreads(__tstate);
34332 if (PyErr_Occurred()) SWIG_fail;
34333 }
34334 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34335 return resultobj;
34336 fail:
34337 return NULL;
34338 }
34339
34340
34341 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34342 PyObject *resultobj = 0;
34343 wxWindow *arg1 = (wxWindow *) 0 ;
34344 int *arg2 = (int *) 0 ;
34345 int *arg3 = (int *) 0 ;
34346 void *argp1 = 0 ;
34347 int res1 = 0 ;
34348 int temp2 ;
34349 int res2 = SWIG_TMPOBJ ;
34350 int temp3 ;
34351 int res3 = SWIG_TMPOBJ ;
34352 PyObject *swig_obj[1] ;
34353
34354 arg2 = &temp2;
34355 arg3 = &temp3;
34356 if (!args) SWIG_fail;
34357 swig_obj[0] = args;
34358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34359 if (!SWIG_IsOK(res1)) {
34360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34361 }
34362 arg1 = reinterpret_cast< wxWindow * >(argp1);
34363 {
34364 PyThreadState* __tstate = wxPyBeginAllowThreads();
34365 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34366 wxPyEndAllowThreads(__tstate);
34367 if (PyErr_Occurred()) SWIG_fail;
34368 }
34369 resultobj = SWIG_Py_Void();
34370 if (SWIG_IsTmpObj(res2)) {
34371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34372 } else {
34373 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34375 }
34376 if (SWIG_IsTmpObj(res3)) {
34377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34378 } else {
34379 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34381 }
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34389 PyObject *resultobj = 0;
34390 wxWindow *arg1 = (wxWindow *) 0 ;
34391 wxPoint result;
34392 void *argp1 = 0 ;
34393 int res1 = 0 ;
34394 PyObject *swig_obj[1] ;
34395
34396 if (!args) SWIG_fail;
34397 swig_obj[0] = args;
34398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34399 if (!SWIG_IsOK(res1)) {
34400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34401 }
34402 arg1 = reinterpret_cast< wxWindow * >(argp1);
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 wxRect result;
34420 void *argp1 = 0 ;
34421 int res1 = 0 ;
34422 PyObject *swig_obj[1] ;
34423
34424 if (!args) SWIG_fail;
34425 swig_obj[0] = args;
34426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34427 if (!SWIG_IsOK(res1)) {
34428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34429 }
34430 arg1 = reinterpret_cast< wxWindow * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = ((wxWindow const *)arg1)->GetClientRect();
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34445 PyObject *resultobj = 0;
34446 wxWindow *arg1 = (wxWindow *) 0 ;
34447 wxSize result;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 PyObject *swig_obj[1] ;
34451
34452 if (!args) SWIG_fail;
34453 swig_obj[0] = args;
34454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34457 }
34458 arg1 = reinterpret_cast< wxWindow * >(argp1);
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 result = ((wxWindow const *)arg1)->GetBestSize();
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34466 return resultobj;
34467 fail:
34468 return NULL;
34469 }
34470
34471
34472 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34473 PyObject *resultobj = 0;
34474 wxWindow *arg1 = (wxWindow *) 0 ;
34475 int *arg2 = (int *) 0 ;
34476 int *arg3 = (int *) 0 ;
34477 void *argp1 = 0 ;
34478 int res1 = 0 ;
34479 int temp2 ;
34480 int res2 = SWIG_TMPOBJ ;
34481 int temp3 ;
34482 int res3 = SWIG_TMPOBJ ;
34483 PyObject *swig_obj[1] ;
34484
34485 arg2 = &temp2;
34486 arg3 = &temp3;
34487 if (!args) SWIG_fail;
34488 swig_obj[0] = args;
34489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34492 }
34493 arg1 = reinterpret_cast< wxWindow * >(argp1);
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 resultobj = SWIG_Py_Void();
34501 if (SWIG_IsTmpObj(res2)) {
34502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34503 } else {
34504 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34506 }
34507 if (SWIG_IsTmpObj(res3)) {
34508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34509 } else {
34510 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34512 }
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34520 PyObject *resultobj = 0;
34521 wxWindow *arg1 = (wxWindow *) 0 ;
34522 void *argp1 = 0 ;
34523 int res1 = 0 ;
34524 PyObject *swig_obj[1] ;
34525
34526 if (!args) SWIG_fail;
34527 swig_obj[0] = args;
34528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34529 if (!SWIG_IsOK(res1)) {
34530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34531 }
34532 arg1 = reinterpret_cast< wxWindow * >(argp1);
34533 {
34534 PyThreadState* __tstate = wxPyBeginAllowThreads();
34535 (arg1)->InvalidateBestSize();
34536 wxPyEndAllowThreads(__tstate);
34537 if (PyErr_Occurred()) SWIG_fail;
34538 }
34539 resultobj = SWIG_Py_Void();
34540 return resultobj;
34541 fail:
34542 return NULL;
34543 }
34544
34545
34546 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34547 PyObject *resultobj = 0;
34548 wxWindow *arg1 = (wxWindow *) 0 ;
34549 wxSize *arg2 = 0 ;
34550 void *argp1 = 0 ;
34551 int res1 = 0 ;
34552 wxSize temp2 ;
34553 PyObject * obj0 = 0 ;
34554 PyObject * obj1 = 0 ;
34555 char * kwnames[] = {
34556 (char *) "self",(char *) "size", NULL
34557 };
34558
34559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34561 if (!SWIG_IsOK(res1)) {
34562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34563 }
34564 arg1 = reinterpret_cast< wxWindow * >(argp1);
34565 {
34566 arg2 = &temp2;
34567 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34568 }
34569 {
34570 PyThreadState* __tstate = wxPyBeginAllowThreads();
34571 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34572 wxPyEndAllowThreads(__tstate);
34573 if (PyErr_Occurred()) SWIG_fail;
34574 }
34575 resultobj = SWIG_Py_Void();
34576 return resultobj;
34577 fail:
34578 return NULL;
34579 }
34580
34581
34582 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34583 PyObject *resultobj = 0;
34584 wxWindow *arg1 = (wxWindow *) 0 ;
34585 wxSize result;
34586 void *argp1 = 0 ;
34587 int res1 = 0 ;
34588 PyObject *swig_obj[1] ;
34589
34590 if (!args) SWIG_fail;
34591 swig_obj[0] = args;
34592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34593 if (!SWIG_IsOK(res1)) {
34594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34595 }
34596 arg1 = reinterpret_cast< wxWindow * >(argp1);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 int arg2 = (int) wxBOTH ;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 int val2 ;
34617 int ecode2 = 0 ;
34618 PyObject * obj0 = 0 ;
34619 PyObject * obj1 = 0 ;
34620 char * kwnames[] = {
34621 (char *) "self",(char *) "direction", NULL
34622 };
34623
34624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34626 if (!SWIG_IsOK(res1)) {
34627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34628 }
34629 arg1 = reinterpret_cast< wxWindow * >(argp1);
34630 if (obj1) {
34631 ecode2 = SWIG_AsVal_int(obj1, &val2);
34632 if (!SWIG_IsOK(ecode2)) {
34633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34634 }
34635 arg2 = static_cast< int >(val2);
34636 }
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 (arg1)->Center(arg2);
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 resultobj = SWIG_Py_Void();
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 int arg2 = (int) wxBOTH ;
34654 void *argp1 = 0 ;
34655 int res1 = 0 ;
34656 int val2 ;
34657 int ecode2 = 0 ;
34658 PyObject * obj0 = 0 ;
34659 PyObject * obj1 = 0 ;
34660 char * kwnames[] = {
34661 (char *) "self",(char *) "dir", NULL
34662 };
34663
34664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34666 if (!SWIG_IsOK(res1)) {
34667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34668 }
34669 arg1 = reinterpret_cast< wxWindow * >(argp1);
34670 if (obj1) {
34671 ecode2 = SWIG_AsVal_int(obj1, &val2);
34672 if (!SWIG_IsOK(ecode2)) {
34673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34674 }
34675 arg2 = static_cast< int >(val2);
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 (arg1)->CenterOnParent(arg2);
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 resultobj = SWIG_Py_Void();
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 void *argp1 = 0 ;
34694 int res1 = 0 ;
34695 PyObject *swig_obj[1] ;
34696
34697 if (!args) SWIG_fail;
34698 swig_obj[0] = args;
34699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34700 if (!SWIG_IsOK(res1)) {
34701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34702 }
34703 arg1 = reinterpret_cast< wxWindow * >(argp1);
34704 {
34705 PyThreadState* __tstate = wxPyBeginAllowThreads();
34706 (arg1)->Fit();
34707 wxPyEndAllowThreads(__tstate);
34708 if (PyErr_Occurred()) SWIG_fail;
34709 }
34710 resultobj = SWIG_Py_Void();
34711 return resultobj;
34712 fail:
34713 return NULL;
34714 }
34715
34716
34717 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34718 PyObject *resultobj = 0;
34719 wxWindow *arg1 = (wxWindow *) 0 ;
34720 void *argp1 = 0 ;
34721 int res1 = 0 ;
34722 PyObject *swig_obj[1] ;
34723
34724 if (!args) SWIG_fail;
34725 swig_obj[0] = args;
34726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34727 if (!SWIG_IsOK(res1)) {
34728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34729 }
34730 arg1 = reinterpret_cast< wxWindow * >(argp1);
34731 {
34732 PyThreadState* __tstate = wxPyBeginAllowThreads();
34733 (arg1)->FitInside();
34734 wxPyEndAllowThreads(__tstate);
34735 if (PyErr_Occurred()) SWIG_fail;
34736 }
34737 resultobj = SWIG_Py_Void();
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34745 PyObject *resultobj = 0;
34746 wxWindow *arg1 = (wxWindow *) 0 ;
34747 int arg2 ;
34748 int arg3 ;
34749 int arg4 = (int) -1 ;
34750 int arg5 = (int) -1 ;
34751 int arg6 = (int) -1 ;
34752 int arg7 = (int) -1 ;
34753 void *argp1 = 0 ;
34754 int res1 = 0 ;
34755 int val2 ;
34756 int ecode2 = 0 ;
34757 int val3 ;
34758 int ecode3 = 0 ;
34759 int val4 ;
34760 int ecode4 = 0 ;
34761 int val5 ;
34762 int ecode5 = 0 ;
34763 int val6 ;
34764 int ecode6 = 0 ;
34765 int val7 ;
34766 int ecode7 = 0 ;
34767 PyObject * obj0 = 0 ;
34768 PyObject * obj1 = 0 ;
34769 PyObject * obj2 = 0 ;
34770 PyObject * obj3 = 0 ;
34771 PyObject * obj4 = 0 ;
34772 PyObject * obj5 = 0 ;
34773 PyObject * obj6 = 0 ;
34774 char * kwnames[] = {
34775 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34776 };
34777
34778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34782 }
34783 arg1 = reinterpret_cast< wxWindow * >(argp1);
34784 ecode2 = SWIG_AsVal_int(obj1, &val2);
34785 if (!SWIG_IsOK(ecode2)) {
34786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34787 }
34788 arg2 = static_cast< int >(val2);
34789 ecode3 = SWIG_AsVal_int(obj2, &val3);
34790 if (!SWIG_IsOK(ecode3)) {
34791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34792 }
34793 arg3 = static_cast< int >(val3);
34794 if (obj3) {
34795 ecode4 = SWIG_AsVal_int(obj3, &val4);
34796 if (!SWIG_IsOK(ecode4)) {
34797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34798 }
34799 arg4 = static_cast< int >(val4);
34800 }
34801 if (obj4) {
34802 ecode5 = SWIG_AsVal_int(obj4, &val5);
34803 if (!SWIG_IsOK(ecode5)) {
34804 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34805 }
34806 arg5 = static_cast< int >(val5);
34807 }
34808 if (obj5) {
34809 ecode6 = SWIG_AsVal_int(obj5, &val6);
34810 if (!SWIG_IsOK(ecode6)) {
34811 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34812 }
34813 arg6 = static_cast< int >(val6);
34814 }
34815 if (obj6) {
34816 ecode7 = SWIG_AsVal_int(obj6, &val7);
34817 if (!SWIG_IsOK(ecode7)) {
34818 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34819 }
34820 arg7 = static_cast< int >(val7);
34821 }
34822 {
34823 PyThreadState* __tstate = wxPyBeginAllowThreads();
34824 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34825 wxPyEndAllowThreads(__tstate);
34826 if (PyErr_Occurred()) SWIG_fail;
34827 }
34828 resultobj = SWIG_Py_Void();
34829 return resultobj;
34830 fail:
34831 return NULL;
34832 }
34833
34834
34835 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34836 PyObject *resultobj = 0;
34837 wxWindow *arg1 = (wxWindow *) 0 ;
34838 wxSize *arg2 = 0 ;
34839 wxSize const &arg3_defvalue = wxDefaultSize ;
34840 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34841 wxSize const &arg4_defvalue = wxDefaultSize ;
34842 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34843 void *argp1 = 0 ;
34844 int res1 = 0 ;
34845 wxSize temp2 ;
34846 wxSize temp3 ;
34847 wxSize temp4 ;
34848 PyObject * obj0 = 0 ;
34849 PyObject * obj1 = 0 ;
34850 PyObject * obj2 = 0 ;
34851 PyObject * obj3 = 0 ;
34852 char * kwnames[] = {
34853 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34854 };
34855
34856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34858 if (!SWIG_IsOK(res1)) {
34859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34860 }
34861 arg1 = reinterpret_cast< wxWindow * >(argp1);
34862 {
34863 arg2 = &temp2;
34864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34865 }
34866 if (obj2) {
34867 {
34868 arg3 = &temp3;
34869 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34870 }
34871 }
34872 if (obj3) {
34873 {
34874 arg4 = &temp4;
34875 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34876 }
34877 }
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34881 wxPyEndAllowThreads(__tstate);
34882 if (PyErr_Occurred()) SWIG_fail;
34883 }
34884 resultobj = SWIG_Py_Void();
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj = 0;
34893 wxWindow *arg1 = (wxWindow *) 0 ;
34894 int arg2 ;
34895 int arg3 ;
34896 int arg4 = (int) -1 ;
34897 int arg5 = (int) -1 ;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 int val2 ;
34901 int ecode2 = 0 ;
34902 int val3 ;
34903 int ecode3 = 0 ;
34904 int val4 ;
34905 int ecode4 = 0 ;
34906 int val5 ;
34907 int ecode5 = 0 ;
34908 PyObject * obj0 = 0 ;
34909 PyObject * obj1 = 0 ;
34910 PyObject * obj2 = 0 ;
34911 PyObject * obj3 = 0 ;
34912 PyObject * obj4 = 0 ;
34913 char * kwnames[] = {
34914 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34915 };
34916
34917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34919 if (!SWIG_IsOK(res1)) {
34920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34921 }
34922 arg1 = reinterpret_cast< wxWindow * >(argp1);
34923 ecode2 = SWIG_AsVal_int(obj1, &val2);
34924 if (!SWIG_IsOK(ecode2)) {
34925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34926 }
34927 arg2 = static_cast< int >(val2);
34928 ecode3 = SWIG_AsVal_int(obj2, &val3);
34929 if (!SWIG_IsOK(ecode3)) {
34930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34931 }
34932 arg3 = static_cast< int >(val3);
34933 if (obj3) {
34934 ecode4 = SWIG_AsVal_int(obj3, &val4);
34935 if (!SWIG_IsOK(ecode4)) {
34936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34937 }
34938 arg4 = static_cast< int >(val4);
34939 }
34940 if (obj4) {
34941 ecode5 = SWIG_AsVal_int(obj4, &val5);
34942 if (!SWIG_IsOK(ecode5)) {
34943 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34944 }
34945 arg5 = static_cast< int >(val5);
34946 }
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 resultobj = SWIG_Py_Void();
34954 return resultobj;
34955 fail:
34956 return NULL;
34957 }
34958
34959
34960 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34961 PyObject *resultobj = 0;
34962 wxWindow *arg1 = (wxWindow *) 0 ;
34963 wxSize *arg2 = 0 ;
34964 wxSize const &arg3_defvalue = wxDefaultSize ;
34965 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 wxSize temp2 ;
34969 wxSize temp3 ;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 PyObject * obj2 = 0 ;
34973 char * kwnames[] = {
34974 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34975 };
34976
34977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34979 if (!SWIG_IsOK(res1)) {
34980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34981 }
34982 arg1 = reinterpret_cast< wxWindow * >(argp1);
34983 {
34984 arg2 = &temp2;
34985 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34986 }
34987 if (obj2) {
34988 {
34989 arg3 = &temp3;
34990 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34991 }
34992 }
34993 {
34994 PyThreadState* __tstate = wxPyBeginAllowThreads();
34995 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34996 wxPyEndAllowThreads(__tstate);
34997 if (PyErr_Occurred()) SWIG_fail;
34998 }
34999 resultobj = SWIG_Py_Void();
35000 return resultobj;
35001 fail:
35002 return NULL;
35003 }
35004
35005
35006 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35007 PyObject *resultobj = 0;
35008 wxWindow *arg1 = (wxWindow *) 0 ;
35009 wxSize result;
35010 void *argp1 = 0 ;
35011 int res1 = 0 ;
35012 PyObject *swig_obj[1] ;
35013
35014 if (!args) SWIG_fail;
35015 swig_obj[0] = args;
35016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35017 if (!SWIG_IsOK(res1)) {
35018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35019 }
35020 arg1 = reinterpret_cast< wxWindow * >(argp1);
35021 {
35022 PyThreadState* __tstate = wxPyBeginAllowThreads();
35023 result = ((wxWindow const *)arg1)->GetMaxSize();
35024 wxPyEndAllowThreads(__tstate);
35025 if (PyErr_Occurred()) SWIG_fail;
35026 }
35027 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35028 return resultobj;
35029 fail:
35030 return NULL;
35031 }
35032
35033
35034 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35035 PyObject *resultobj = 0;
35036 wxWindow *arg1 = (wxWindow *) 0 ;
35037 wxSize result;
35038 void *argp1 = 0 ;
35039 int res1 = 0 ;
35040 PyObject *swig_obj[1] ;
35041
35042 if (!args) SWIG_fail;
35043 swig_obj[0] = args;
35044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35045 if (!SWIG_IsOK(res1)) {
35046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35047 }
35048 arg1 = reinterpret_cast< wxWindow * >(argp1);
35049 {
35050 PyThreadState* __tstate = wxPyBeginAllowThreads();
35051 result = ((wxWindow const *)arg1)->GetMinSize();
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35056 return resultobj;
35057 fail:
35058 return NULL;
35059 }
35060
35061
35062 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35063 PyObject *resultobj = 0;
35064 wxWindow *arg1 = (wxWindow *) 0 ;
35065 wxSize *arg2 = 0 ;
35066 void *argp1 = 0 ;
35067 int res1 = 0 ;
35068 wxSize temp2 ;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 char * kwnames[] = {
35072 (char *) "self",(char *) "minSize", NULL
35073 };
35074
35075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35079 }
35080 arg1 = reinterpret_cast< wxWindow * >(argp1);
35081 {
35082 arg2 = &temp2;
35083 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35084 }
35085 {
35086 PyThreadState* __tstate = wxPyBeginAllowThreads();
35087 (arg1)->SetMinSize((wxSize const &)*arg2);
35088 wxPyEndAllowThreads(__tstate);
35089 if (PyErr_Occurred()) SWIG_fail;
35090 }
35091 resultobj = SWIG_Py_Void();
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj = 0;
35100 wxWindow *arg1 = (wxWindow *) 0 ;
35101 wxSize *arg2 = 0 ;
35102 void *argp1 = 0 ;
35103 int res1 = 0 ;
35104 wxSize temp2 ;
35105 PyObject * obj0 = 0 ;
35106 PyObject * obj1 = 0 ;
35107 char * kwnames[] = {
35108 (char *) "self",(char *) "maxSize", NULL
35109 };
35110
35111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 {
35118 arg2 = &temp2;
35119 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35120 }
35121 {
35122 PyThreadState* __tstate = wxPyBeginAllowThreads();
35123 (arg1)->SetMaxSize((wxSize const &)*arg2);
35124 wxPyEndAllowThreads(__tstate);
35125 if (PyErr_Occurred()) SWIG_fail;
35126 }
35127 resultobj = SWIG_Py_Void();
35128 return resultobj;
35129 fail:
35130 return NULL;
35131 }
35132
35133
35134 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35135 PyObject *resultobj = 0;
35136 wxWindow *arg1 = (wxWindow *) 0 ;
35137 int result;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 PyObject *swig_obj[1] ;
35141
35142 if (!args) SWIG_fail;
35143 swig_obj[0] = args;
35144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 {
35150 PyThreadState* __tstate = wxPyBeginAllowThreads();
35151 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 resultobj = SWIG_From_int(static_cast< int >(result));
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35163 PyObject *resultobj = 0;
35164 wxWindow *arg1 = (wxWindow *) 0 ;
35165 int result;
35166 void *argp1 = 0 ;
35167 int res1 = 0 ;
35168 PyObject *swig_obj[1] ;
35169
35170 if (!args) SWIG_fail;
35171 swig_obj[0] = args;
35172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35173 if (!SWIG_IsOK(res1)) {
35174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35175 }
35176 arg1 = reinterpret_cast< wxWindow * >(argp1);
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35180 wxPyEndAllowThreads(__tstate);
35181 if (PyErr_Occurred()) SWIG_fail;
35182 }
35183 resultobj = SWIG_From_int(static_cast< int >(result));
35184 return resultobj;
35185 fail:
35186 return NULL;
35187 }
35188
35189
35190 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35191 PyObject *resultobj = 0;
35192 wxWindow *arg1 = (wxWindow *) 0 ;
35193 int result;
35194 void *argp1 = 0 ;
35195 int res1 = 0 ;
35196 PyObject *swig_obj[1] ;
35197
35198 if (!args) SWIG_fail;
35199 swig_obj[0] = args;
35200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35201 if (!SWIG_IsOK(res1)) {
35202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35203 }
35204 arg1 = reinterpret_cast< wxWindow * >(argp1);
35205 {
35206 PyThreadState* __tstate = wxPyBeginAllowThreads();
35207 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 resultobj = SWIG_From_int(static_cast< int >(result));
35212 return resultobj;
35213 fail:
35214 return NULL;
35215 }
35216
35217
35218 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35219 PyObject *resultobj = 0;
35220 wxWindow *arg1 = (wxWindow *) 0 ;
35221 int result;
35222 void *argp1 = 0 ;
35223 int res1 = 0 ;
35224 PyObject *swig_obj[1] ;
35225
35226 if (!args) SWIG_fail;
35227 swig_obj[0] = args;
35228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35229 if (!SWIG_IsOK(res1)) {
35230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35231 }
35232 arg1 = reinterpret_cast< wxWindow * >(argp1);
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35236 wxPyEndAllowThreads(__tstate);
35237 if (PyErr_Occurred()) SWIG_fail;
35238 }
35239 resultobj = SWIG_From_int(static_cast< int >(result));
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35247 PyObject *resultobj = 0;
35248 wxWindow *arg1 = (wxWindow *) 0 ;
35249 wxSize *arg2 = 0 ;
35250 void *argp1 = 0 ;
35251 int res1 = 0 ;
35252 wxSize temp2 ;
35253 PyObject * obj0 = 0 ;
35254 PyObject * obj1 = 0 ;
35255 char * kwnames[] = {
35256 (char *) "self",(char *) "size", NULL
35257 };
35258
35259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35261 if (!SWIG_IsOK(res1)) {
35262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35263 }
35264 arg1 = reinterpret_cast< wxWindow * >(argp1);
35265 {
35266 arg2 = &temp2;
35267 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35268 }
35269 {
35270 PyThreadState* __tstate = wxPyBeginAllowThreads();
35271 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35272 wxPyEndAllowThreads(__tstate);
35273 if (PyErr_Occurred()) SWIG_fail;
35274 }
35275 resultobj = SWIG_Py_Void();
35276 return resultobj;
35277 fail:
35278 return NULL;
35279 }
35280
35281
35282 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35283 PyObject *resultobj = 0;
35284 wxWindow *arg1 = (wxWindow *) 0 ;
35285 int arg2 ;
35286 int arg3 ;
35287 void *argp1 = 0 ;
35288 int res1 = 0 ;
35289 int val2 ;
35290 int ecode2 = 0 ;
35291 int val3 ;
35292 int ecode3 = 0 ;
35293 PyObject * obj0 = 0 ;
35294 PyObject * obj1 = 0 ;
35295 PyObject * obj2 = 0 ;
35296 char * kwnames[] = {
35297 (char *) "self",(char *) "w",(char *) "h", NULL
35298 };
35299
35300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 ecode2 = SWIG_AsVal_int(obj1, &val2);
35307 if (!SWIG_IsOK(ecode2)) {
35308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35309 }
35310 arg2 = static_cast< int >(val2);
35311 ecode3 = SWIG_AsVal_int(obj2, &val3);
35312 if (!SWIG_IsOK(ecode3)) {
35313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35314 }
35315 arg3 = static_cast< int >(val3);
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 (arg1)->SetVirtualSize(arg2,arg3);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 resultobj = SWIG_Py_Void();
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35330 PyObject *resultobj = 0;
35331 wxWindow *arg1 = (wxWindow *) 0 ;
35332 wxSize result;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 PyObject *swig_obj[1] ;
35336
35337 if (!args) SWIG_fail;
35338 swig_obj[0] = args;
35339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35340 if (!SWIG_IsOK(res1)) {
35341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35342 }
35343 arg1 = reinterpret_cast< wxWindow * >(argp1);
35344 {
35345 PyThreadState* __tstate = wxPyBeginAllowThreads();
35346 result = ((wxWindow const *)arg1)->GetVirtualSize();
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35358 PyObject *resultobj = 0;
35359 wxWindow *arg1 = (wxWindow *) 0 ;
35360 int *arg2 = (int *) 0 ;
35361 int *arg3 = (int *) 0 ;
35362 void *argp1 = 0 ;
35363 int res1 = 0 ;
35364 int temp2 ;
35365 int res2 = SWIG_TMPOBJ ;
35366 int temp3 ;
35367 int res3 = SWIG_TMPOBJ ;
35368 PyObject *swig_obj[1] ;
35369
35370 arg2 = &temp2;
35371 arg3 = &temp3;
35372 if (!args) SWIG_fail;
35373 swig_obj[0] = args;
35374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35377 }
35378 arg1 = reinterpret_cast< wxWindow * >(argp1);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 resultobj = SWIG_Py_Void();
35386 if (SWIG_IsTmpObj(res2)) {
35387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35388 } else {
35389 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35391 }
35392 if (SWIG_IsTmpObj(res3)) {
35393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35394 } else {
35395 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35397 }
35398 return resultobj;
35399 fail:
35400 return NULL;
35401 }
35402
35403
35404 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35405 PyObject *resultobj = 0;
35406 wxWindow *arg1 = (wxWindow *) 0 ;
35407 wxSize result;
35408 void *argp1 = 0 ;
35409 int res1 = 0 ;
35410 PyObject *swig_obj[1] ;
35411
35412 if (!args) SWIG_fail;
35413 swig_obj[0] = args;
35414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35417 }
35418 arg1 = reinterpret_cast< wxWindow * >(argp1);
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35422 wxPyEndAllowThreads(__tstate);
35423 if (PyErr_Occurred()) SWIG_fail;
35424 }
35425 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35433 PyObject *resultobj = 0;
35434 wxWindow *arg1 = (wxWindow *) 0 ;
35435 bool arg2 = (bool) true ;
35436 bool result;
35437 void *argp1 = 0 ;
35438 int res1 = 0 ;
35439 bool val2 ;
35440 int ecode2 = 0 ;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char * kwnames[] = {
35444 (char *) "self",(char *) "show", NULL
35445 };
35446
35447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35449 if (!SWIG_IsOK(res1)) {
35450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35451 }
35452 arg1 = reinterpret_cast< wxWindow * >(argp1);
35453 if (obj1) {
35454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35455 if (!SWIG_IsOK(ecode2)) {
35456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35457 }
35458 arg2 = static_cast< bool >(val2);
35459 }
35460 {
35461 PyThreadState* __tstate = wxPyBeginAllowThreads();
35462 result = (bool)(arg1)->Show(arg2);
35463 wxPyEndAllowThreads(__tstate);
35464 if (PyErr_Occurred()) SWIG_fail;
35465 }
35466 {
35467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35468 }
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35476 PyObject *resultobj = 0;
35477 wxWindow *arg1 = (wxWindow *) 0 ;
35478 bool result;
35479 void *argp1 = 0 ;
35480 int res1 = 0 ;
35481 PyObject *swig_obj[1] ;
35482
35483 if (!args) SWIG_fail;
35484 swig_obj[0] = args;
35485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35486 if (!SWIG_IsOK(res1)) {
35487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35488 }
35489 arg1 = reinterpret_cast< wxWindow * >(argp1);
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (bool)(arg1)->Hide();
35493 wxPyEndAllowThreads(__tstate);
35494 if (PyErr_Occurred()) SWIG_fail;
35495 }
35496 {
35497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35498 }
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35506 PyObject *resultobj = 0;
35507 wxWindow *arg1 = (wxWindow *) 0 ;
35508 bool arg2 = (bool) true ;
35509 bool result;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 bool val2 ;
35513 int ecode2 = 0 ;
35514 PyObject * obj0 = 0 ;
35515 PyObject * obj1 = 0 ;
35516 char * kwnames[] = {
35517 (char *) "self",(char *) "enable", NULL
35518 };
35519
35520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35522 if (!SWIG_IsOK(res1)) {
35523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35524 }
35525 arg1 = reinterpret_cast< wxWindow * >(argp1);
35526 if (obj1) {
35527 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35528 if (!SWIG_IsOK(ecode2)) {
35529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35530 }
35531 arg2 = static_cast< bool >(val2);
35532 }
35533 {
35534 PyThreadState* __tstate = wxPyBeginAllowThreads();
35535 result = (bool)(arg1)->Enable(arg2);
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 {
35540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35541 }
35542 return resultobj;
35543 fail:
35544 return NULL;
35545 }
35546
35547
35548 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35549 PyObject *resultobj = 0;
35550 wxWindow *arg1 = (wxWindow *) 0 ;
35551 bool result;
35552 void *argp1 = 0 ;
35553 int res1 = 0 ;
35554 PyObject *swig_obj[1] ;
35555
35556 if (!args) SWIG_fail;
35557 swig_obj[0] = args;
35558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35559 if (!SWIG_IsOK(res1)) {
35560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35561 }
35562 arg1 = reinterpret_cast< wxWindow * >(argp1);
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 result = (bool)(arg1)->Disable();
35566 wxPyEndAllowThreads(__tstate);
35567 if (PyErr_Occurred()) SWIG_fail;
35568 }
35569 {
35570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35571 }
35572 return resultobj;
35573 fail:
35574 return NULL;
35575 }
35576
35577
35578 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35579 PyObject *resultobj = 0;
35580 wxWindow *arg1 = (wxWindow *) 0 ;
35581 bool result;
35582 void *argp1 = 0 ;
35583 int res1 = 0 ;
35584 PyObject *swig_obj[1] ;
35585
35586 if (!args) SWIG_fail;
35587 swig_obj[0] = args;
35588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35589 if (!SWIG_IsOK(res1)) {
35590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35591 }
35592 arg1 = reinterpret_cast< wxWindow * >(argp1);
35593 {
35594 PyThreadState* __tstate = wxPyBeginAllowThreads();
35595 result = (bool)((wxWindow const *)arg1)->IsShown();
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 {
35600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35601 }
35602 return resultobj;
35603 fail:
35604 return NULL;
35605 }
35606
35607
35608 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35609 PyObject *resultobj = 0;
35610 wxWindow *arg1 = (wxWindow *) 0 ;
35611 bool result;
35612 void *argp1 = 0 ;
35613 int res1 = 0 ;
35614 PyObject *swig_obj[1] ;
35615
35616 if (!args) SWIG_fail;
35617 swig_obj[0] = args;
35618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35621 }
35622 arg1 = reinterpret_cast< wxWindow * >(argp1);
35623 {
35624 PyThreadState* __tstate = wxPyBeginAllowThreads();
35625 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35626 wxPyEndAllowThreads(__tstate);
35627 if (PyErr_Occurred()) SWIG_fail;
35628 }
35629 {
35630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35631 }
35632 return resultobj;
35633 fail:
35634 return NULL;
35635 }
35636
35637
35638 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35639 PyObject *resultobj = 0;
35640 wxWindow *arg1 = (wxWindow *) 0 ;
35641 bool result;
35642 void *argp1 = 0 ;
35643 int res1 = 0 ;
35644 PyObject *swig_obj[1] ;
35645
35646 if (!args) SWIG_fail;
35647 swig_obj[0] = args;
35648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35649 if (!SWIG_IsOK(res1)) {
35650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35651 }
35652 arg1 = reinterpret_cast< wxWindow * >(argp1);
35653 {
35654 PyThreadState* __tstate = wxPyBeginAllowThreads();
35655 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35656 wxPyEndAllowThreads(__tstate);
35657 if (PyErr_Occurred()) SWIG_fail;
35658 }
35659 {
35660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35661 }
35662 return resultobj;
35663 fail:
35664 return NULL;
35665 }
35666
35667
35668 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35669 PyObject *resultobj = 0;
35670 wxWindow *arg1 = (wxWindow *) 0 ;
35671 long arg2 ;
35672 void *argp1 = 0 ;
35673 int res1 = 0 ;
35674 long val2 ;
35675 int ecode2 = 0 ;
35676 PyObject * obj0 = 0 ;
35677 PyObject * obj1 = 0 ;
35678 char * kwnames[] = {
35679 (char *) "self",(char *) "style", NULL
35680 };
35681
35682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35684 if (!SWIG_IsOK(res1)) {
35685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35686 }
35687 arg1 = reinterpret_cast< wxWindow * >(argp1);
35688 ecode2 = SWIG_AsVal_long(obj1, &val2);
35689 if (!SWIG_IsOK(ecode2)) {
35690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35691 }
35692 arg2 = static_cast< long >(val2);
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 (arg1)->SetWindowStyleFlag(arg2);
35696 wxPyEndAllowThreads(__tstate);
35697 if (PyErr_Occurred()) SWIG_fail;
35698 }
35699 resultobj = SWIG_Py_Void();
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35707 PyObject *resultobj = 0;
35708 wxWindow *arg1 = (wxWindow *) 0 ;
35709 long result;
35710 void *argp1 = 0 ;
35711 int res1 = 0 ;
35712 PyObject *swig_obj[1] ;
35713
35714 if (!args) SWIG_fail;
35715 swig_obj[0] = args;
35716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35719 }
35720 arg1 = reinterpret_cast< wxWindow * >(argp1);
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35724 wxPyEndAllowThreads(__tstate);
35725 if (PyErr_Occurred()) SWIG_fail;
35726 }
35727 resultobj = SWIG_From_long(static_cast< long >(result));
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 int arg2 ;
35738 bool result;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 int val2 ;
35742 int ecode2 = 0 ;
35743 PyObject * obj0 = 0 ;
35744 PyObject * obj1 = 0 ;
35745 char * kwnames[] = {
35746 (char *) "self",(char *) "flag", NULL
35747 };
35748
35749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35751 if (!SWIG_IsOK(res1)) {
35752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35753 }
35754 arg1 = reinterpret_cast< wxWindow * >(argp1);
35755 ecode2 = SWIG_AsVal_int(obj1, &val2);
35756 if (!SWIG_IsOK(ecode2)) {
35757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35758 }
35759 arg2 = static_cast< int >(val2);
35760 {
35761 PyThreadState* __tstate = wxPyBeginAllowThreads();
35762 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35763 wxPyEndAllowThreads(__tstate);
35764 if (PyErr_Occurred()) SWIG_fail;
35765 }
35766 {
35767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35768 }
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35776 PyObject *resultobj = 0;
35777 wxWindow *arg1 = (wxWindow *) 0 ;
35778 bool result;
35779 void *argp1 = 0 ;
35780 int res1 = 0 ;
35781 PyObject *swig_obj[1] ;
35782
35783 if (!args) SWIG_fail;
35784 swig_obj[0] = args;
35785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35786 if (!SWIG_IsOK(res1)) {
35787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35788 }
35789 arg1 = reinterpret_cast< wxWindow * >(argp1);
35790 {
35791 PyThreadState* __tstate = wxPyBeginAllowThreads();
35792 result = (bool)((wxWindow const *)arg1)->IsRetained();
35793 wxPyEndAllowThreads(__tstate);
35794 if (PyErr_Occurred()) SWIG_fail;
35795 }
35796 {
35797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35798 }
35799 return resultobj;
35800 fail:
35801 return NULL;
35802 }
35803
35804
35805 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35806 PyObject *resultobj = 0;
35807 wxWindow *arg1 = (wxWindow *) 0 ;
35808 long arg2 ;
35809 void *argp1 = 0 ;
35810 int res1 = 0 ;
35811 long val2 ;
35812 int ecode2 = 0 ;
35813 PyObject * obj0 = 0 ;
35814 PyObject * obj1 = 0 ;
35815 char * kwnames[] = {
35816 (char *) "self",(char *) "exStyle", NULL
35817 };
35818
35819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35821 if (!SWIG_IsOK(res1)) {
35822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35823 }
35824 arg1 = reinterpret_cast< wxWindow * >(argp1);
35825 ecode2 = SWIG_AsVal_long(obj1, &val2);
35826 if (!SWIG_IsOK(ecode2)) {
35827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35828 }
35829 arg2 = static_cast< long >(val2);
35830 {
35831 PyThreadState* __tstate = wxPyBeginAllowThreads();
35832 (arg1)->SetExtraStyle(arg2);
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 resultobj = SWIG_Py_Void();
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35844 PyObject *resultobj = 0;
35845 wxWindow *arg1 = (wxWindow *) 0 ;
35846 long result;
35847 void *argp1 = 0 ;
35848 int res1 = 0 ;
35849 PyObject *swig_obj[1] ;
35850
35851 if (!args) SWIG_fail;
35852 swig_obj[0] = args;
35853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35854 if (!SWIG_IsOK(res1)) {
35855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35856 }
35857 arg1 = reinterpret_cast< wxWindow * >(argp1);
35858 {
35859 PyThreadState* __tstate = wxPyBeginAllowThreads();
35860 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35861 wxPyEndAllowThreads(__tstate);
35862 if (PyErr_Occurred()) SWIG_fail;
35863 }
35864 resultobj = SWIG_From_long(static_cast< long >(result));
35865 return resultobj;
35866 fail:
35867 return NULL;
35868 }
35869
35870
35871 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35872 PyObject *resultobj = 0;
35873 wxWindow *arg1 = (wxWindow *) 0 ;
35874 bool arg2 = (bool) true ;
35875 void *argp1 = 0 ;
35876 int res1 = 0 ;
35877 bool val2 ;
35878 int ecode2 = 0 ;
35879 PyObject * obj0 = 0 ;
35880 PyObject * obj1 = 0 ;
35881 char * kwnames[] = {
35882 (char *) "self",(char *) "modal", NULL
35883 };
35884
35885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35887 if (!SWIG_IsOK(res1)) {
35888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35889 }
35890 arg1 = reinterpret_cast< wxWindow * >(argp1);
35891 if (obj1) {
35892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35893 if (!SWIG_IsOK(ecode2)) {
35894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35895 }
35896 arg2 = static_cast< bool >(val2);
35897 }
35898 {
35899 PyThreadState* __tstate = wxPyBeginAllowThreads();
35900 (arg1)->MakeModal(arg2);
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 resultobj = SWIG_Py_Void();
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj = 0;
35913 wxWindow *arg1 = (wxWindow *) 0 ;
35914 bool arg2 ;
35915 void *argp1 = 0 ;
35916 int res1 = 0 ;
35917 bool val2 ;
35918 int ecode2 = 0 ;
35919 PyObject * obj0 = 0 ;
35920 PyObject * obj1 = 0 ;
35921 char * kwnames[] = {
35922 (char *) "self",(char *) "enableTheme", NULL
35923 };
35924
35925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35927 if (!SWIG_IsOK(res1)) {
35928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35929 }
35930 arg1 = reinterpret_cast< wxWindow * >(argp1);
35931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35932 if (!SWIG_IsOK(ecode2)) {
35933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35934 }
35935 arg2 = static_cast< bool >(val2);
35936 {
35937 PyThreadState* __tstate = wxPyBeginAllowThreads();
35938 (arg1)->SetThemeEnabled(arg2);
35939 wxPyEndAllowThreads(__tstate);
35940 if (PyErr_Occurred()) SWIG_fail;
35941 }
35942 resultobj = SWIG_Py_Void();
35943 return resultobj;
35944 fail:
35945 return NULL;
35946 }
35947
35948
35949 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35950 PyObject *resultobj = 0;
35951 wxWindow *arg1 = (wxWindow *) 0 ;
35952 bool result;
35953 void *argp1 = 0 ;
35954 int res1 = 0 ;
35955 PyObject *swig_obj[1] ;
35956
35957 if (!args) SWIG_fail;
35958 swig_obj[0] = args;
35959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35960 if (!SWIG_IsOK(res1)) {
35961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35962 }
35963 arg1 = reinterpret_cast< wxWindow * >(argp1);
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 {
35971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35972 }
35973 return resultobj;
35974 fail:
35975 return NULL;
35976 }
35977
35978
35979 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35980 PyObject *resultobj = 0;
35981 wxWindow *arg1 = (wxWindow *) 0 ;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 PyObject *swig_obj[1] ;
35985
35986 if (!args) SWIG_fail;
35987 swig_obj[0] = args;
35988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35989 if (!SWIG_IsOK(res1)) {
35990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
35991 }
35992 arg1 = reinterpret_cast< wxWindow * >(argp1);
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 (arg1)->SetFocus();
35996 wxPyEndAllowThreads(__tstate);
35997 if (PyErr_Occurred()) SWIG_fail;
35998 }
35999 resultobj = SWIG_Py_Void();
36000 return resultobj;
36001 fail:
36002 return NULL;
36003 }
36004
36005
36006 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36007 PyObject *resultobj = 0;
36008 wxWindow *arg1 = (wxWindow *) 0 ;
36009 void *argp1 = 0 ;
36010 int res1 = 0 ;
36011 PyObject *swig_obj[1] ;
36012
36013 if (!args) SWIG_fail;
36014 swig_obj[0] = args;
36015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36016 if (!SWIG_IsOK(res1)) {
36017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36018 }
36019 arg1 = reinterpret_cast< wxWindow * >(argp1);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 (arg1)->SetFocusFromKbd();
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 resultobj = SWIG_Py_Void();
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxWindow *result = 0 ;
36036
36037 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36038 {
36039 if (!wxPyCheckForApp()) SWIG_fail;
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 result = (wxWindow *)wxWindow::FindFocus();
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 {
36046 resultobj = wxPyMake_wxObject(result, 0);
36047 }
36048 return resultobj;
36049 fail:
36050 return NULL;
36051 }
36052
36053
36054 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36055 PyObject *resultobj = 0;
36056 wxWindow *arg1 = (wxWindow *) 0 ;
36057 bool result;
36058 void *argp1 = 0 ;
36059 int res1 = 0 ;
36060 PyObject *swig_obj[1] ;
36061
36062 if (!args) SWIG_fail;
36063 swig_obj[0] = args;
36064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36065 if (!SWIG_IsOK(res1)) {
36066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36067 }
36068 arg1 = reinterpret_cast< wxWindow * >(argp1);
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 {
36076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36077 }
36078 return resultobj;
36079 fail:
36080 return NULL;
36081 }
36082
36083
36084 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36085 PyObject *resultobj = 0;
36086 wxWindow *arg1 = (wxWindow *) 0 ;
36087 bool result;
36088 void *argp1 = 0 ;
36089 int res1 = 0 ;
36090 PyObject *swig_obj[1] ;
36091
36092 if (!args) SWIG_fail;
36093 swig_obj[0] = args;
36094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36095 if (!SWIG_IsOK(res1)) {
36096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36097 }
36098 arg1 = reinterpret_cast< wxWindow * >(argp1);
36099 {
36100 PyThreadState* __tstate = wxPyBeginAllowThreads();
36101 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36102 wxPyEndAllowThreads(__tstate);
36103 if (PyErr_Occurred()) SWIG_fail;
36104 }
36105 {
36106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36107 }
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36115 PyObject *resultobj = 0;
36116 wxWindow *arg1 = (wxWindow *) 0 ;
36117 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36118 bool result;
36119 void *argp1 = 0 ;
36120 int res1 = 0 ;
36121 int val2 ;
36122 int ecode2 = 0 ;
36123 PyObject * obj0 = 0 ;
36124 PyObject * obj1 = 0 ;
36125 char * kwnames[] = {
36126 (char *) "self",(char *) "flags", NULL
36127 };
36128
36129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 if (obj1) {
36136 ecode2 = SWIG_AsVal_int(obj1, &val2);
36137 if (!SWIG_IsOK(ecode2)) {
36138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36139 }
36140 arg2 = static_cast< int >(val2);
36141 }
36142 {
36143 PyThreadState* __tstate = wxPyBeginAllowThreads();
36144 result = (bool)(arg1)->Navigate(arg2);
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 {
36149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36150 }
36151 return resultobj;
36152 fail:
36153 return NULL;
36154 }
36155
36156
36157 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36158 PyObject *resultobj = 0;
36159 wxWindow *arg1 = (wxWindow *) 0 ;
36160 wxWindow *arg2 = (wxWindow *) 0 ;
36161 void *argp1 = 0 ;
36162 int res1 = 0 ;
36163 void *argp2 = 0 ;
36164 int res2 = 0 ;
36165 PyObject * obj0 = 0 ;
36166 PyObject * obj1 = 0 ;
36167 char * kwnames[] = {
36168 (char *) "self",(char *) "win", NULL
36169 };
36170
36171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36173 if (!SWIG_IsOK(res1)) {
36174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36175 }
36176 arg1 = reinterpret_cast< wxWindow * >(argp1);
36177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36178 if (!SWIG_IsOK(res2)) {
36179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36180 }
36181 arg2 = reinterpret_cast< wxWindow * >(argp2);
36182 {
36183 PyThreadState* __tstate = wxPyBeginAllowThreads();
36184 (arg1)->MoveAfterInTabOrder(arg2);
36185 wxPyEndAllowThreads(__tstate);
36186 if (PyErr_Occurred()) SWIG_fail;
36187 }
36188 resultobj = SWIG_Py_Void();
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36196 PyObject *resultobj = 0;
36197 wxWindow *arg1 = (wxWindow *) 0 ;
36198 wxWindow *arg2 = (wxWindow *) 0 ;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 void *argp2 = 0 ;
36202 int res2 = 0 ;
36203 PyObject * obj0 = 0 ;
36204 PyObject * obj1 = 0 ;
36205 char * kwnames[] = {
36206 (char *) "self",(char *) "win", NULL
36207 };
36208
36209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36211 if (!SWIG_IsOK(res1)) {
36212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36213 }
36214 arg1 = reinterpret_cast< wxWindow * >(argp1);
36215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36216 if (!SWIG_IsOK(res2)) {
36217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36218 }
36219 arg2 = reinterpret_cast< wxWindow * >(argp2);
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 (arg1)->MoveBeforeInTabOrder(arg2);
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_Py_Void();
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36234 PyObject *resultobj = 0;
36235 wxWindow *arg1 = (wxWindow *) 0 ;
36236 PyObject *result = 0 ;
36237 void *argp1 = 0 ;
36238 int res1 = 0 ;
36239 PyObject *swig_obj[1] ;
36240
36241 if (!args) SWIG_fail;
36242 swig_obj[0] = args;
36243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36244 if (!SWIG_IsOK(res1)) {
36245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36246 }
36247 arg1 = reinterpret_cast< wxWindow * >(argp1);
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = (PyObject *)wxWindow_GetChildren(arg1);
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 resultobj = result;
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36262 PyObject *resultobj = 0;
36263 wxWindow *arg1 = (wxWindow *) 0 ;
36264 wxWindow *result = 0 ;
36265 void *argp1 = 0 ;
36266 int res1 = 0 ;
36267 PyObject *swig_obj[1] ;
36268
36269 if (!args) SWIG_fail;
36270 swig_obj[0] = args;
36271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36272 if (!SWIG_IsOK(res1)) {
36273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36274 }
36275 arg1 = reinterpret_cast< wxWindow * >(argp1);
36276 {
36277 PyThreadState* __tstate = wxPyBeginAllowThreads();
36278 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36279 wxPyEndAllowThreads(__tstate);
36280 if (PyErr_Occurred()) SWIG_fail;
36281 }
36282 {
36283 resultobj = wxPyMake_wxObject(result, 0);
36284 }
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxWindow *arg1 = (wxWindow *) 0 ;
36294 wxWindow *result = 0 ;
36295 void *argp1 = 0 ;
36296 int res1 = 0 ;
36297 PyObject *swig_obj[1] ;
36298
36299 if (!args) SWIG_fail;
36300 swig_obj[0] = args;
36301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36304 }
36305 arg1 = reinterpret_cast< wxWindow * >(argp1);
36306 {
36307 PyThreadState* __tstate = wxPyBeginAllowThreads();
36308 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36309 wxPyEndAllowThreads(__tstate);
36310 if (PyErr_Occurred()) SWIG_fail;
36311 }
36312 {
36313 resultobj = wxPyMake_wxObject(result, 0);
36314 }
36315 return resultobj;
36316 fail:
36317 return NULL;
36318 }
36319
36320
36321 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36322 PyObject *resultobj = 0;
36323 wxWindow *arg1 = (wxWindow *) 0 ;
36324 bool result;
36325 void *argp1 = 0 ;
36326 int res1 = 0 ;
36327 PyObject *swig_obj[1] ;
36328
36329 if (!args) SWIG_fail;
36330 swig_obj[0] = args;
36331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36332 if (!SWIG_IsOK(res1)) {
36333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36334 }
36335 arg1 = reinterpret_cast< wxWindow * >(argp1);
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36339 wxPyEndAllowThreads(__tstate);
36340 if (PyErr_Occurred()) SWIG_fail;
36341 }
36342 {
36343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36344 }
36345 return resultobj;
36346 fail:
36347 return NULL;
36348 }
36349
36350
36351 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36352 PyObject *resultobj = 0;
36353 wxWindow *arg1 = (wxWindow *) 0 ;
36354 wxWindow *arg2 = (wxWindow *) 0 ;
36355 bool result;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 void *argp2 = 0 ;
36359 int res2 = 0 ;
36360 PyObject * obj0 = 0 ;
36361 PyObject * obj1 = 0 ;
36362 char * kwnames[] = {
36363 (char *) "self",(char *) "newParent", NULL
36364 };
36365
36366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36368 if (!SWIG_IsOK(res1)) {
36369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36370 }
36371 arg1 = reinterpret_cast< wxWindow * >(argp1);
36372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36373 if (!SWIG_IsOK(res2)) {
36374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36375 }
36376 arg2 = reinterpret_cast< wxWindow * >(argp2);
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = (bool)(arg1)->Reparent(arg2);
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj = 0;
36394 wxWindow *arg1 = (wxWindow *) 0 ;
36395 wxWindow *arg2 = (wxWindow *) 0 ;
36396 void *argp1 = 0 ;
36397 int res1 = 0 ;
36398 void *argp2 = 0 ;
36399 int res2 = 0 ;
36400 PyObject * obj0 = 0 ;
36401 PyObject * obj1 = 0 ;
36402 char * kwnames[] = {
36403 (char *) "self",(char *) "child", NULL
36404 };
36405
36406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36408 if (!SWIG_IsOK(res1)) {
36409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36410 }
36411 arg1 = reinterpret_cast< wxWindow * >(argp1);
36412 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36413 if (!SWIG_IsOK(res2)) {
36414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36415 }
36416 arg2 = reinterpret_cast< wxWindow * >(argp2);
36417 {
36418 PyThreadState* __tstate = wxPyBeginAllowThreads();
36419 (arg1)->AddChild(arg2);
36420 wxPyEndAllowThreads(__tstate);
36421 if (PyErr_Occurred()) SWIG_fail;
36422 }
36423 resultobj = SWIG_Py_Void();
36424 return resultobj;
36425 fail:
36426 return NULL;
36427 }
36428
36429
36430 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36431 PyObject *resultobj = 0;
36432 wxWindow *arg1 = (wxWindow *) 0 ;
36433 wxWindow *arg2 = (wxWindow *) 0 ;
36434 void *argp1 = 0 ;
36435 int res1 = 0 ;
36436 void *argp2 = 0 ;
36437 int res2 = 0 ;
36438 PyObject * obj0 = 0 ;
36439 PyObject * obj1 = 0 ;
36440 char * kwnames[] = {
36441 (char *) "self",(char *) "child", NULL
36442 };
36443
36444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36446 if (!SWIG_IsOK(res1)) {
36447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36448 }
36449 arg1 = reinterpret_cast< wxWindow * >(argp1);
36450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36451 if (!SWIG_IsOK(res2)) {
36452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36453 }
36454 arg2 = reinterpret_cast< wxWindow * >(argp2);
36455 {
36456 PyThreadState* __tstate = wxPyBeginAllowThreads();
36457 (arg1)->RemoveChild(arg2);
36458 wxPyEndAllowThreads(__tstate);
36459 if (PyErr_Occurred()) SWIG_fail;
36460 }
36461 resultobj = SWIG_Py_Void();
36462 return resultobj;
36463 fail:
36464 return NULL;
36465 }
36466
36467
36468 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36469 PyObject *resultobj = 0;
36470 wxWindow *arg1 = (wxWindow *) 0 ;
36471 bool arg2 ;
36472 void *argp1 = 0 ;
36473 int res1 = 0 ;
36474 bool val2 ;
36475 int ecode2 = 0 ;
36476 PyObject * obj0 = 0 ;
36477 PyObject * obj1 = 0 ;
36478 char * kwnames[] = {
36479 (char *) "self",(char *) "on", NULL
36480 };
36481
36482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36486 }
36487 arg1 = reinterpret_cast< wxWindow * >(argp1);
36488 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36489 if (!SWIG_IsOK(ecode2)) {
36490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36491 }
36492 arg2 = static_cast< bool >(val2);
36493 {
36494 PyThreadState* __tstate = wxPyBeginAllowThreads();
36495 wxWindow_SetDoubleBuffered(arg1,arg2);
36496 wxPyEndAllowThreads(__tstate);
36497 if (PyErr_Occurred()) SWIG_fail;
36498 }
36499 resultobj = SWIG_Py_Void();
36500 return resultobj;
36501 fail:
36502 return NULL;
36503 }
36504
36505
36506 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36507 PyObject *resultobj = 0;
36508 wxWindow *arg1 = (wxWindow *) 0 ;
36509 long arg2 ;
36510 wxWindow *result = 0 ;
36511 void *argp1 = 0 ;
36512 int res1 = 0 ;
36513 long val2 ;
36514 int ecode2 = 0 ;
36515 PyObject * obj0 = 0 ;
36516 PyObject * obj1 = 0 ;
36517 char * kwnames[] = {
36518 (char *) "self",(char *) "winid", NULL
36519 };
36520
36521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36523 if (!SWIG_IsOK(res1)) {
36524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36525 }
36526 arg1 = reinterpret_cast< wxWindow * >(argp1);
36527 ecode2 = SWIG_AsVal_long(obj1, &val2);
36528 if (!SWIG_IsOK(ecode2)) {
36529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36530 }
36531 arg2 = static_cast< long >(val2);
36532 {
36533 PyThreadState* __tstate = wxPyBeginAllowThreads();
36534 result = (wxWindow *)(arg1)->FindWindow(arg2);
36535 wxPyEndAllowThreads(__tstate);
36536 if (PyErr_Occurred()) SWIG_fail;
36537 }
36538 {
36539 resultobj = wxPyMake_wxObject(result, 0);
36540 }
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj = 0;
36549 wxWindow *arg1 = (wxWindow *) 0 ;
36550 wxString *arg2 = 0 ;
36551 wxWindow *result = 0 ;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 bool temp2 = false ;
36555 PyObject * obj0 = 0 ;
36556 PyObject * obj1 = 0 ;
36557 char * kwnames[] = {
36558 (char *) "self",(char *) "name", NULL
36559 };
36560
36561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36563 if (!SWIG_IsOK(res1)) {
36564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36565 }
36566 arg1 = reinterpret_cast< wxWindow * >(argp1);
36567 {
36568 arg2 = wxString_in_helper(obj1);
36569 if (arg2 == NULL) SWIG_fail;
36570 temp2 = true;
36571 }
36572 {
36573 PyThreadState* __tstate = wxPyBeginAllowThreads();
36574 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36575 wxPyEndAllowThreads(__tstate);
36576 if (PyErr_Occurred()) SWIG_fail;
36577 }
36578 {
36579 resultobj = wxPyMake_wxObject(result, 0);
36580 }
36581 {
36582 if (temp2)
36583 delete arg2;
36584 }
36585 return resultobj;
36586 fail:
36587 {
36588 if (temp2)
36589 delete arg2;
36590 }
36591 return NULL;
36592 }
36593
36594
36595 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36596 PyObject *resultobj = 0;
36597 wxWindow *arg1 = (wxWindow *) 0 ;
36598 wxEvtHandler *result = 0 ;
36599 void *argp1 = 0 ;
36600 int res1 = 0 ;
36601 PyObject *swig_obj[1] ;
36602
36603 if (!args) SWIG_fail;
36604 swig_obj[0] = args;
36605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36608 }
36609 arg1 = reinterpret_cast< wxWindow * >(argp1);
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 {
36617 resultobj = wxPyMake_wxObject(result, 0);
36618 }
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj = 0;
36627 wxWindow *arg1 = (wxWindow *) 0 ;
36628 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36629 void *argp1 = 0 ;
36630 int res1 = 0 ;
36631 void *argp2 = 0 ;
36632 int res2 = 0 ;
36633 PyObject * obj0 = 0 ;
36634 PyObject * obj1 = 0 ;
36635 char * kwnames[] = {
36636 (char *) "self",(char *) "handler", NULL
36637 };
36638
36639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36641 if (!SWIG_IsOK(res1)) {
36642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36643 }
36644 arg1 = reinterpret_cast< wxWindow * >(argp1);
36645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36646 if (!SWIG_IsOK(res2)) {
36647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36648 }
36649 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36650 {
36651 PyThreadState* __tstate = wxPyBeginAllowThreads();
36652 (arg1)->SetEventHandler(arg2);
36653 wxPyEndAllowThreads(__tstate);
36654 if (PyErr_Occurred()) SWIG_fail;
36655 }
36656 resultobj = SWIG_Py_Void();
36657 return resultobj;
36658 fail:
36659 return NULL;
36660 }
36661
36662
36663 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36664 PyObject *resultobj = 0;
36665 wxWindow *arg1 = (wxWindow *) 0 ;
36666 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36667 void *argp1 = 0 ;
36668 int res1 = 0 ;
36669 void *argp2 = 0 ;
36670 int res2 = 0 ;
36671 PyObject * obj0 = 0 ;
36672 PyObject * obj1 = 0 ;
36673 char * kwnames[] = {
36674 (char *) "self",(char *) "handler", NULL
36675 };
36676
36677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36679 if (!SWIG_IsOK(res1)) {
36680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36681 }
36682 arg1 = reinterpret_cast< wxWindow * >(argp1);
36683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36684 if (!SWIG_IsOK(res2)) {
36685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36686 }
36687 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36688 {
36689 PyThreadState* __tstate = wxPyBeginAllowThreads();
36690 (arg1)->PushEventHandler(arg2);
36691 wxPyEndAllowThreads(__tstate);
36692 if (PyErr_Occurred()) SWIG_fail;
36693 }
36694 resultobj = SWIG_Py_Void();
36695 return resultobj;
36696 fail:
36697 return NULL;
36698 }
36699
36700
36701 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36702 PyObject *resultobj = 0;
36703 wxWindow *arg1 = (wxWindow *) 0 ;
36704 bool arg2 = (bool) false ;
36705 wxEvtHandler *result = 0 ;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 bool val2 ;
36709 int ecode2 = 0 ;
36710 PyObject * obj0 = 0 ;
36711 PyObject * obj1 = 0 ;
36712 char * kwnames[] = {
36713 (char *) "self",(char *) "deleteHandler", NULL
36714 };
36715
36716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36718 if (!SWIG_IsOK(res1)) {
36719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36720 }
36721 arg1 = reinterpret_cast< wxWindow * >(argp1);
36722 if (obj1) {
36723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36724 if (!SWIG_IsOK(ecode2)) {
36725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36726 }
36727 arg2 = static_cast< bool >(val2);
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 {
36736 resultobj = wxPyMake_wxObject(result, 0);
36737 }
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36745 PyObject *resultobj = 0;
36746 wxWindow *arg1 = (wxWindow *) 0 ;
36747 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36748 bool result;
36749 void *argp1 = 0 ;
36750 int res1 = 0 ;
36751 void *argp2 = 0 ;
36752 int res2 = 0 ;
36753 PyObject * obj0 = 0 ;
36754 PyObject * obj1 = 0 ;
36755 char * kwnames[] = {
36756 (char *) "self",(char *) "handler", NULL
36757 };
36758
36759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36761 if (!SWIG_IsOK(res1)) {
36762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36763 }
36764 arg1 = reinterpret_cast< wxWindow * >(argp1);
36765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36766 if (!SWIG_IsOK(res2)) {
36767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36768 }
36769 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36770 {
36771 PyThreadState* __tstate = wxPyBeginAllowThreads();
36772 result = (bool)(arg1)->RemoveEventHandler(arg2);
36773 wxPyEndAllowThreads(__tstate);
36774 if (PyErr_Occurred()) SWIG_fail;
36775 }
36776 {
36777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36778 }
36779 return resultobj;
36780 fail:
36781 return NULL;
36782 }
36783
36784
36785 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36786 PyObject *resultobj = 0;
36787 wxWindow *arg1 = (wxWindow *) 0 ;
36788 wxValidator *arg2 = 0 ;
36789 void *argp1 = 0 ;
36790 int res1 = 0 ;
36791 void *argp2 = 0 ;
36792 int res2 = 0 ;
36793 PyObject * obj0 = 0 ;
36794 PyObject * obj1 = 0 ;
36795 char * kwnames[] = {
36796 (char *) "self",(char *) "validator", NULL
36797 };
36798
36799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36801 if (!SWIG_IsOK(res1)) {
36802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36803 }
36804 arg1 = reinterpret_cast< wxWindow * >(argp1);
36805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36806 if (!SWIG_IsOK(res2)) {
36807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36808 }
36809 if (!argp2) {
36810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36811 }
36812 arg2 = reinterpret_cast< wxValidator * >(argp2);
36813 {
36814 PyThreadState* __tstate = wxPyBeginAllowThreads();
36815 (arg1)->SetValidator((wxValidator const &)*arg2);
36816 wxPyEndAllowThreads(__tstate);
36817 if (PyErr_Occurred()) SWIG_fail;
36818 }
36819 resultobj = SWIG_Py_Void();
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 wxValidator *result = 0 ;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 PyObject *swig_obj[1] ;
36833
36834 if (!args) SWIG_fail;
36835 swig_obj[0] = args;
36836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36837 if (!SWIG_IsOK(res1)) {
36838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36839 }
36840 arg1 = reinterpret_cast< wxWindow * >(argp1);
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 result = (wxValidator *)(arg1)->GetValidator();
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 {
36848 resultobj = wxPyMake_wxObject(result, (bool)0);
36849 }
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36857 PyObject *resultobj = 0;
36858 wxWindow *arg1 = (wxWindow *) 0 ;
36859 bool result;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 PyObject *swig_obj[1] ;
36863
36864 if (!args) SWIG_fail;
36865 swig_obj[0] = args;
36866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (bool)(arg1)->Validate();
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 {
36878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36879 }
36880 return resultobj;
36881 fail:
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36887 PyObject *resultobj = 0;
36888 wxWindow *arg1 = (wxWindow *) 0 ;
36889 bool result;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 PyObject *swig_obj[1] ;
36893
36894 if (!args) SWIG_fail;
36895 swig_obj[0] = args;
36896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36897 if (!SWIG_IsOK(res1)) {
36898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36899 }
36900 arg1 = reinterpret_cast< wxWindow * >(argp1);
36901 {
36902 PyThreadState* __tstate = wxPyBeginAllowThreads();
36903 result = (bool)(arg1)->TransferDataToWindow();
36904 wxPyEndAllowThreads(__tstate);
36905 if (PyErr_Occurred()) SWIG_fail;
36906 }
36907 {
36908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36909 }
36910 return resultobj;
36911 fail:
36912 return NULL;
36913 }
36914
36915
36916 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36917 PyObject *resultobj = 0;
36918 wxWindow *arg1 = (wxWindow *) 0 ;
36919 bool result;
36920 void *argp1 = 0 ;
36921 int res1 = 0 ;
36922 PyObject *swig_obj[1] ;
36923
36924 if (!args) SWIG_fail;
36925 swig_obj[0] = args;
36926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36927 if (!SWIG_IsOK(res1)) {
36928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36929 }
36930 arg1 = reinterpret_cast< wxWindow * >(argp1);
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 result = (bool)(arg1)->TransferDataFromWindow();
36934 wxPyEndAllowThreads(__tstate);
36935 if (PyErr_Occurred()) SWIG_fail;
36936 }
36937 {
36938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36939 }
36940 return resultobj;
36941 fail:
36942 return NULL;
36943 }
36944
36945
36946 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36947 PyObject *resultobj = 0;
36948 wxWindow *arg1 = (wxWindow *) 0 ;
36949 void *argp1 = 0 ;
36950 int res1 = 0 ;
36951 PyObject *swig_obj[1] ;
36952
36953 if (!args) SWIG_fail;
36954 swig_obj[0] = args;
36955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36956 if (!SWIG_IsOK(res1)) {
36957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36958 }
36959 arg1 = reinterpret_cast< wxWindow * >(argp1);
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 (arg1)->InitDialog();
36963 wxPyEndAllowThreads(__tstate);
36964 if (PyErr_Occurred()) SWIG_fail;
36965 }
36966 resultobj = SWIG_Py_Void();
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 wxAcceleratorTable *arg2 = 0 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 void *argp2 = 0 ;
36980 int res2 = 0 ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 char * kwnames[] = {
36984 (char *) "self",(char *) "accel", NULL
36985 };
36986
36987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
36988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
36991 }
36992 arg1 = reinterpret_cast< wxWindow * >(argp1);
36993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
36994 if (!SWIG_IsOK(res2)) {
36995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36996 }
36997 if (!argp2) {
36998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36999 }
37000 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 resultobj = SWIG_Py_Void();
37008 return resultobj;
37009 fail:
37010 return NULL;
37011 }
37012
37013
37014 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37015 PyObject *resultobj = 0;
37016 wxWindow *arg1 = (wxWindow *) 0 ;
37017 wxAcceleratorTable *result = 0 ;
37018 void *argp1 = 0 ;
37019 int res1 = 0 ;
37020 PyObject *swig_obj[1] ;
37021
37022 if (!args) SWIG_fail;
37023 swig_obj[0] = args;
37024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37027 }
37028 arg1 = reinterpret_cast< wxWindow * >(argp1);
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37032 wxPyEndAllowThreads(__tstate);
37033 if (PyErr_Occurred()) SWIG_fail;
37034 }
37035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37036 return resultobj;
37037 fail:
37038 return NULL;
37039 }
37040
37041
37042 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37043 PyObject *resultobj = 0;
37044 wxWindow *arg1 = (wxWindow *) 0 ;
37045 int arg2 ;
37046 int arg3 ;
37047 int arg4 ;
37048 bool result;
37049 void *argp1 = 0 ;
37050 int res1 = 0 ;
37051 int val2 ;
37052 int ecode2 = 0 ;
37053 int val3 ;
37054 int ecode3 = 0 ;
37055 int val4 ;
37056 int ecode4 = 0 ;
37057 PyObject * obj0 = 0 ;
37058 PyObject * obj1 = 0 ;
37059 PyObject * obj2 = 0 ;
37060 PyObject * obj3 = 0 ;
37061 char * kwnames[] = {
37062 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37063 };
37064
37065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37067 if (!SWIG_IsOK(res1)) {
37068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37069 }
37070 arg1 = reinterpret_cast< wxWindow * >(argp1);
37071 ecode2 = SWIG_AsVal_int(obj1, &val2);
37072 if (!SWIG_IsOK(ecode2)) {
37073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37074 }
37075 arg2 = static_cast< int >(val2);
37076 ecode3 = SWIG_AsVal_int(obj2, &val3);
37077 if (!SWIG_IsOK(ecode3)) {
37078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37079 }
37080 arg3 = static_cast< int >(val3);
37081 ecode4 = SWIG_AsVal_int(obj3, &val4);
37082 if (!SWIG_IsOK(ecode4)) {
37083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37084 }
37085 arg4 = static_cast< int >(val4);
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37089 wxPyEndAllowThreads(__tstate);
37090 if (PyErr_Occurred()) SWIG_fail;
37091 }
37092 {
37093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37094 }
37095 return resultobj;
37096 fail:
37097 return NULL;
37098 }
37099
37100
37101 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37102 PyObject *resultobj = 0;
37103 wxWindow *arg1 = (wxWindow *) 0 ;
37104 int arg2 ;
37105 bool result;
37106 void *argp1 = 0 ;
37107 int res1 = 0 ;
37108 int val2 ;
37109 int ecode2 = 0 ;
37110 PyObject * obj0 = 0 ;
37111 PyObject * obj1 = 0 ;
37112 char * kwnames[] = {
37113 (char *) "self",(char *) "hotkeyId", NULL
37114 };
37115
37116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37118 if (!SWIG_IsOK(res1)) {
37119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37120 }
37121 arg1 = reinterpret_cast< wxWindow * >(argp1);
37122 ecode2 = SWIG_AsVal_int(obj1, &val2);
37123 if (!SWIG_IsOK(ecode2)) {
37124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37125 }
37126 arg2 = static_cast< int >(val2);
37127 {
37128 PyThreadState* __tstate = wxPyBeginAllowThreads();
37129 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37130 wxPyEndAllowThreads(__tstate);
37131 if (PyErr_Occurred()) SWIG_fail;
37132 }
37133 {
37134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37135 }
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37143 PyObject *resultobj = 0;
37144 wxWindow *arg1 = (wxWindow *) 0 ;
37145 wxPoint *arg2 = 0 ;
37146 wxPoint result;
37147 void *argp1 = 0 ;
37148 int res1 = 0 ;
37149 wxPoint temp2 ;
37150 PyObject * obj0 = 0 ;
37151 PyObject * obj1 = 0 ;
37152 char * kwnames[] = {
37153 (char *) "self",(char *) "pt", NULL
37154 };
37155
37156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37158 if (!SWIG_IsOK(res1)) {
37159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37160 }
37161 arg1 = reinterpret_cast< wxWindow * >(argp1);
37162 {
37163 arg2 = &temp2;
37164 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37165 }
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37173 return resultobj;
37174 fail:
37175 return NULL;
37176 }
37177
37178
37179 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37180 PyObject *resultobj = 0;
37181 wxWindow *arg1 = (wxWindow *) 0 ;
37182 wxSize *arg2 = 0 ;
37183 wxSize result;
37184 void *argp1 = 0 ;
37185 int res1 = 0 ;
37186 wxSize temp2 ;
37187 PyObject * obj0 = 0 ;
37188 PyObject * obj1 = 0 ;
37189 char * kwnames[] = {
37190 (char *) "self",(char *) "sz", NULL
37191 };
37192
37193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37195 if (!SWIG_IsOK(res1)) {
37196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37197 }
37198 arg1 = reinterpret_cast< wxWindow * >(argp1);
37199 {
37200 arg2 = &temp2;
37201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37202 }
37203 {
37204 PyThreadState* __tstate = wxPyBeginAllowThreads();
37205 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37217 PyObject *resultobj = 0;
37218 wxWindow *arg1 = (wxWindow *) 0 ;
37219 wxPoint *arg2 = 0 ;
37220 wxPoint result;
37221 void *argp1 = 0 ;
37222 int res1 = 0 ;
37223 wxPoint temp2 ;
37224 PyObject * obj0 = 0 ;
37225 PyObject * obj1 = 0 ;
37226 char * kwnames[] = {
37227 (char *) "self",(char *) "pt", NULL
37228 };
37229
37230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37232 if (!SWIG_IsOK(res1)) {
37233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37234 }
37235 arg1 = reinterpret_cast< wxWindow * >(argp1);
37236 {
37237 arg2 = &temp2;
37238 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37239 }
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37243 wxPyEndAllowThreads(__tstate);
37244 if (PyErr_Occurred()) SWIG_fail;
37245 }
37246 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37247 return resultobj;
37248 fail:
37249 return NULL;
37250 }
37251
37252
37253 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37254 PyObject *resultobj = 0;
37255 wxWindow *arg1 = (wxWindow *) 0 ;
37256 wxSize *arg2 = 0 ;
37257 wxSize result;
37258 void *argp1 = 0 ;
37259 int res1 = 0 ;
37260 wxSize temp2 ;
37261 PyObject * obj0 = 0 ;
37262 PyObject * obj1 = 0 ;
37263 char * kwnames[] = {
37264 (char *) "self",(char *) "sz", NULL
37265 };
37266
37267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37269 if (!SWIG_IsOK(res1)) {
37270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37271 }
37272 arg1 = reinterpret_cast< wxWindow * >(argp1);
37273 {
37274 arg2 = &temp2;
37275 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37276 }
37277 {
37278 PyThreadState* __tstate = wxPyBeginAllowThreads();
37279 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37280 wxPyEndAllowThreads(__tstate);
37281 if (PyErr_Occurred()) SWIG_fail;
37282 }
37283 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37284 return resultobj;
37285 fail:
37286 return NULL;
37287 }
37288
37289
37290 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37291 PyObject *resultobj = 0;
37292 wxWindow *arg1 = (wxWindow *) 0 ;
37293 wxPoint *arg2 = 0 ;
37294 wxPoint result;
37295 void *argp1 = 0 ;
37296 int res1 = 0 ;
37297 wxPoint temp2 ;
37298 PyObject * obj0 = 0 ;
37299 PyObject * obj1 = 0 ;
37300 char * kwnames[] = {
37301 (char *) "self",(char *) "pt", NULL
37302 };
37303
37304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37306 if (!SWIG_IsOK(res1)) {
37307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37308 }
37309 arg1 = reinterpret_cast< wxWindow * >(argp1);
37310 {
37311 arg2 = &temp2;
37312 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37313 }
37314 {
37315 PyThreadState* __tstate = wxPyBeginAllowThreads();
37316 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37328 PyObject *resultobj = 0;
37329 wxWindow *arg1 = (wxWindow *) 0 ;
37330 wxSize *arg2 = 0 ;
37331 wxSize result;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 wxSize temp2 ;
37335 PyObject * obj0 = 0 ;
37336 PyObject * obj1 = 0 ;
37337 char * kwnames[] = {
37338 (char *) "self",(char *) "sz", NULL
37339 };
37340
37341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37343 if (!SWIG_IsOK(res1)) {
37344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37345 }
37346 arg1 = reinterpret_cast< wxWindow * >(argp1);
37347 {
37348 arg2 = &temp2;
37349 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37350 }
37351 {
37352 PyThreadState* __tstate = wxPyBeginAllowThreads();
37353 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37354 wxPyEndAllowThreads(__tstate);
37355 if (PyErr_Occurred()) SWIG_fail;
37356 }
37357 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37358 return resultobj;
37359 fail:
37360 return NULL;
37361 }
37362
37363
37364 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37365 PyObject *resultobj = 0;
37366 wxWindow *arg1 = (wxWindow *) 0 ;
37367 int arg2 ;
37368 int arg3 ;
37369 void *argp1 = 0 ;
37370 int res1 = 0 ;
37371 int val2 ;
37372 int ecode2 = 0 ;
37373 int val3 ;
37374 int ecode3 = 0 ;
37375 PyObject * obj0 = 0 ;
37376 PyObject * obj1 = 0 ;
37377 PyObject * obj2 = 0 ;
37378 char * kwnames[] = {
37379 (char *) "self",(char *) "x",(char *) "y", NULL
37380 };
37381
37382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37384 if (!SWIG_IsOK(res1)) {
37385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37386 }
37387 arg1 = reinterpret_cast< wxWindow * >(argp1);
37388 ecode2 = SWIG_AsVal_int(obj1, &val2);
37389 if (!SWIG_IsOK(ecode2)) {
37390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37391 }
37392 arg2 = static_cast< int >(val2);
37393 ecode3 = SWIG_AsVal_int(obj2, &val3);
37394 if (!SWIG_IsOK(ecode3)) {
37395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37396 }
37397 arg3 = static_cast< int >(val3);
37398 {
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 (arg1)->WarpPointer(arg2,arg3);
37401 wxPyEndAllowThreads(__tstate);
37402 if (PyErr_Occurred()) SWIG_fail;
37403 }
37404 resultobj = SWIG_Py_Void();
37405 return resultobj;
37406 fail:
37407 return NULL;
37408 }
37409
37410
37411 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37412 PyObject *resultobj = 0;
37413 wxWindow *arg1 = (wxWindow *) 0 ;
37414 void *argp1 = 0 ;
37415 int res1 = 0 ;
37416 PyObject *swig_obj[1] ;
37417
37418 if (!args) SWIG_fail;
37419 swig_obj[0] = args;
37420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37421 if (!SWIG_IsOK(res1)) {
37422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37423 }
37424 arg1 = reinterpret_cast< wxWindow * >(argp1);
37425 {
37426 PyThreadState* __tstate = wxPyBeginAllowThreads();
37427 (arg1)->CaptureMouse();
37428 wxPyEndAllowThreads(__tstate);
37429 if (PyErr_Occurred()) SWIG_fail;
37430 }
37431 resultobj = SWIG_Py_Void();
37432 return resultobj;
37433 fail:
37434 return NULL;
37435 }
37436
37437
37438 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37439 PyObject *resultobj = 0;
37440 wxWindow *arg1 = (wxWindow *) 0 ;
37441 void *argp1 = 0 ;
37442 int res1 = 0 ;
37443 PyObject *swig_obj[1] ;
37444
37445 if (!args) SWIG_fail;
37446 swig_obj[0] = args;
37447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37448 if (!SWIG_IsOK(res1)) {
37449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37450 }
37451 arg1 = reinterpret_cast< wxWindow * >(argp1);
37452 {
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 (arg1)->ReleaseMouse();
37455 wxPyEndAllowThreads(__tstate);
37456 if (PyErr_Occurred()) SWIG_fail;
37457 }
37458 resultobj = SWIG_Py_Void();
37459 return resultobj;
37460 fail:
37461 return NULL;
37462 }
37463
37464
37465 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37466 PyObject *resultobj = 0;
37467 wxWindow *result = 0 ;
37468
37469 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37470 {
37471 if (!wxPyCheckForApp()) SWIG_fail;
37472 PyThreadState* __tstate = wxPyBeginAllowThreads();
37473 result = (wxWindow *)wxWindow::GetCapture();
37474 wxPyEndAllowThreads(__tstate);
37475 if (PyErr_Occurred()) SWIG_fail;
37476 }
37477 {
37478 resultobj = wxPyMake_wxObject(result, 0);
37479 }
37480 return resultobj;
37481 fail:
37482 return NULL;
37483 }
37484
37485
37486 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37487 PyObject *resultobj = 0;
37488 wxWindow *arg1 = (wxWindow *) 0 ;
37489 bool result;
37490 void *argp1 = 0 ;
37491 int res1 = 0 ;
37492 PyObject *swig_obj[1] ;
37493
37494 if (!args) SWIG_fail;
37495 swig_obj[0] = args;
37496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37497 if (!SWIG_IsOK(res1)) {
37498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37499 }
37500 arg1 = reinterpret_cast< wxWindow * >(argp1);
37501 {
37502 PyThreadState* __tstate = wxPyBeginAllowThreads();
37503 result = (bool)((wxWindow const *)arg1)->HasCapture();
37504 wxPyEndAllowThreads(__tstate);
37505 if (PyErr_Occurred()) SWIG_fail;
37506 }
37507 {
37508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37509 }
37510 return resultobj;
37511 fail:
37512 return NULL;
37513 }
37514
37515
37516 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj = 0;
37518 wxWindow *arg1 = (wxWindow *) 0 ;
37519 bool arg2 = (bool) true ;
37520 wxRect *arg3 = (wxRect *) NULL ;
37521 void *argp1 = 0 ;
37522 int res1 = 0 ;
37523 bool val2 ;
37524 int ecode2 = 0 ;
37525 void *argp3 = 0 ;
37526 int res3 = 0 ;
37527 PyObject * obj0 = 0 ;
37528 PyObject * obj1 = 0 ;
37529 PyObject * obj2 = 0 ;
37530 char * kwnames[] = {
37531 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37532 };
37533
37534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37536 if (!SWIG_IsOK(res1)) {
37537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37538 }
37539 arg1 = reinterpret_cast< wxWindow * >(argp1);
37540 if (obj1) {
37541 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37542 if (!SWIG_IsOK(ecode2)) {
37543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37544 }
37545 arg2 = static_cast< bool >(val2);
37546 }
37547 if (obj2) {
37548 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37549 if (!SWIG_IsOK(res3)) {
37550 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37551 }
37552 arg3 = reinterpret_cast< wxRect * >(argp3);
37553 }
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 resultobj = SWIG_Py_Void();
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj = 0;
37569 wxWindow *arg1 = (wxWindow *) 0 ;
37570 wxRect *arg2 = 0 ;
37571 bool arg3 = (bool) true ;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 wxRect temp2 ;
37575 bool val3 ;
37576 int ecode3 = 0 ;
37577 PyObject * obj0 = 0 ;
37578 PyObject * obj1 = 0 ;
37579 PyObject * obj2 = 0 ;
37580 char * kwnames[] = {
37581 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37582 };
37583
37584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37586 if (!SWIG_IsOK(res1)) {
37587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37588 }
37589 arg1 = reinterpret_cast< wxWindow * >(argp1);
37590 {
37591 arg2 = &temp2;
37592 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37593 }
37594 if (obj2) {
37595 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37596 if (!SWIG_IsOK(ecode3)) {
37597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37598 }
37599 arg3 = static_cast< bool >(val3);
37600 }
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37604 wxPyEndAllowThreads(__tstate);
37605 if (PyErr_Occurred()) SWIG_fail;
37606 }
37607 resultobj = SWIG_Py_Void();
37608 return resultobj;
37609 fail:
37610 return NULL;
37611 }
37612
37613
37614 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37615 PyObject *resultobj = 0;
37616 wxWindow *arg1 = (wxWindow *) 0 ;
37617 void *argp1 = 0 ;
37618 int res1 = 0 ;
37619 PyObject *swig_obj[1] ;
37620
37621 if (!args) SWIG_fail;
37622 swig_obj[0] = args;
37623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37624 if (!SWIG_IsOK(res1)) {
37625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37626 }
37627 arg1 = reinterpret_cast< wxWindow * >(argp1);
37628 {
37629 PyThreadState* __tstate = wxPyBeginAllowThreads();
37630 (arg1)->Update();
37631 wxPyEndAllowThreads(__tstate);
37632 if (PyErr_Occurred()) SWIG_fail;
37633 }
37634 resultobj = SWIG_Py_Void();
37635 return resultobj;
37636 fail:
37637 return NULL;
37638 }
37639
37640
37641 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37642 PyObject *resultobj = 0;
37643 wxWindow *arg1 = (wxWindow *) 0 ;
37644 void *argp1 = 0 ;
37645 int res1 = 0 ;
37646 PyObject *swig_obj[1] ;
37647
37648 if (!args) SWIG_fail;
37649 swig_obj[0] = args;
37650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37651 if (!SWIG_IsOK(res1)) {
37652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37653 }
37654 arg1 = reinterpret_cast< wxWindow * >(argp1);
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 (arg1)->ClearBackground();
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 resultobj = SWIG_Py_Void();
37662 return resultobj;
37663 fail:
37664 return NULL;
37665 }
37666
37667
37668 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37669 PyObject *resultobj = 0;
37670 wxWindow *arg1 = (wxWindow *) 0 ;
37671 void *argp1 = 0 ;
37672 int res1 = 0 ;
37673 PyObject *swig_obj[1] ;
37674
37675 if (!args) SWIG_fail;
37676 swig_obj[0] = args;
37677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37678 if (!SWIG_IsOK(res1)) {
37679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37680 }
37681 arg1 = reinterpret_cast< wxWindow * >(argp1);
37682 {
37683 PyThreadState* __tstate = wxPyBeginAllowThreads();
37684 (arg1)->Freeze();
37685 wxPyEndAllowThreads(__tstate);
37686 if (PyErr_Occurred()) SWIG_fail;
37687 }
37688 resultobj = SWIG_Py_Void();
37689 return resultobj;
37690 fail:
37691 return NULL;
37692 }
37693
37694
37695 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37696 PyObject *resultobj = 0;
37697 wxWindow *arg1 = (wxWindow *) 0 ;
37698 bool result;
37699 void *argp1 = 0 ;
37700 int res1 = 0 ;
37701 PyObject *swig_obj[1] ;
37702
37703 if (!args) SWIG_fail;
37704 swig_obj[0] = args;
37705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37706 if (!SWIG_IsOK(res1)) {
37707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37708 }
37709 arg1 = reinterpret_cast< wxWindow * >(argp1);
37710 {
37711 PyThreadState* __tstate = wxPyBeginAllowThreads();
37712 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37713 wxPyEndAllowThreads(__tstate);
37714 if (PyErr_Occurred()) SWIG_fail;
37715 }
37716 {
37717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37718 }
37719 return resultobj;
37720 fail:
37721 return NULL;
37722 }
37723
37724
37725 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37726 PyObject *resultobj = 0;
37727 wxWindow *arg1 = (wxWindow *) 0 ;
37728 void *argp1 = 0 ;
37729 int res1 = 0 ;
37730 PyObject *swig_obj[1] ;
37731
37732 if (!args) SWIG_fail;
37733 swig_obj[0] = args;
37734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37735 if (!SWIG_IsOK(res1)) {
37736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37737 }
37738 arg1 = reinterpret_cast< wxWindow * >(argp1);
37739 {
37740 PyThreadState* __tstate = wxPyBeginAllowThreads();
37741 (arg1)->Thaw();
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 resultobj = SWIG_Py_Void();
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37753 PyObject *resultobj = 0;
37754 wxWindow *arg1 = (wxWindow *) 0 ;
37755 wxDC *arg2 = 0 ;
37756 void *argp1 = 0 ;
37757 int res1 = 0 ;
37758 void *argp2 = 0 ;
37759 int res2 = 0 ;
37760 PyObject * obj0 = 0 ;
37761 PyObject * obj1 = 0 ;
37762 char * kwnames[] = {
37763 (char *) "self",(char *) "dc", NULL
37764 };
37765
37766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37768 if (!SWIG_IsOK(res1)) {
37769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37770 }
37771 arg1 = reinterpret_cast< wxWindow * >(argp1);
37772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37773 if (!SWIG_IsOK(res2)) {
37774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37775 }
37776 if (!argp2) {
37777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37778 }
37779 arg2 = reinterpret_cast< wxDC * >(argp2);
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->PrepareDC(*arg2);
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 resultobj = SWIG_Py_Void();
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37794 PyObject *resultobj = 0;
37795 wxWindow *arg1 = (wxWindow *) 0 ;
37796 bool result;
37797 void *argp1 = 0 ;
37798 int res1 = 0 ;
37799 PyObject *swig_obj[1] ;
37800
37801 if (!args) SWIG_fail;
37802 swig_obj[0] = args;
37803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37804 if (!SWIG_IsOK(res1)) {
37805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37806 }
37807 arg1 = reinterpret_cast< wxWindow * >(argp1);
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37811 wxPyEndAllowThreads(__tstate);
37812 if (PyErr_Occurred()) SWIG_fail;
37813 }
37814 {
37815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37816 }
37817 return resultobj;
37818 fail:
37819 return NULL;
37820 }
37821
37822
37823 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37824 PyObject *resultobj = 0;
37825 wxWindow *arg1 = (wxWindow *) 0 ;
37826 wxRegion *result = 0 ;
37827 void *argp1 = 0 ;
37828 int res1 = 0 ;
37829 PyObject *swig_obj[1] ;
37830
37831 if (!args) SWIG_fail;
37832 swig_obj[0] = args;
37833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37834 if (!SWIG_IsOK(res1)) {
37835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37836 }
37837 arg1 = reinterpret_cast< wxWindow * >(argp1);
37838 {
37839 PyThreadState* __tstate = wxPyBeginAllowThreads();
37840 {
37841 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37842 result = (wxRegion *) &_result_ref;
37843 }
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37848 return resultobj;
37849 fail:
37850 return NULL;
37851 }
37852
37853
37854 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37855 PyObject *resultobj = 0;
37856 wxWindow *arg1 = (wxWindow *) 0 ;
37857 wxRect result;
37858 void *argp1 = 0 ;
37859 int res1 = 0 ;
37860 PyObject *swig_obj[1] ;
37861
37862 if (!args) SWIG_fail;
37863 swig_obj[0] = args;
37864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37865 if (!SWIG_IsOK(res1)) {
37866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37867 }
37868 arg1 = reinterpret_cast< wxWindow * >(argp1);
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37872 wxPyEndAllowThreads(__tstate);
37873 if (PyErr_Occurred()) SWIG_fail;
37874 }
37875 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37876 return resultobj;
37877 fail:
37878 return NULL;
37879 }
37880
37881
37882 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37883 PyObject *resultobj = 0;
37884 wxWindow *arg1 = (wxWindow *) 0 ;
37885 int arg2 ;
37886 int arg3 ;
37887 int arg4 = (int) 1 ;
37888 int arg5 = (int) 1 ;
37889 bool result;
37890 void *argp1 = 0 ;
37891 int res1 = 0 ;
37892 int val2 ;
37893 int ecode2 = 0 ;
37894 int val3 ;
37895 int ecode3 = 0 ;
37896 int val4 ;
37897 int ecode4 = 0 ;
37898 int val5 ;
37899 int ecode5 = 0 ;
37900 PyObject * obj0 = 0 ;
37901 PyObject * obj1 = 0 ;
37902 PyObject * obj2 = 0 ;
37903 PyObject * obj3 = 0 ;
37904 PyObject * obj4 = 0 ;
37905 char * kwnames[] = {
37906 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37907 };
37908
37909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37911 if (!SWIG_IsOK(res1)) {
37912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37913 }
37914 arg1 = reinterpret_cast< wxWindow * >(argp1);
37915 ecode2 = SWIG_AsVal_int(obj1, &val2);
37916 if (!SWIG_IsOK(ecode2)) {
37917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37918 }
37919 arg2 = static_cast< int >(val2);
37920 ecode3 = SWIG_AsVal_int(obj2, &val3);
37921 if (!SWIG_IsOK(ecode3)) {
37922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37923 }
37924 arg3 = static_cast< int >(val3);
37925 if (obj3) {
37926 ecode4 = SWIG_AsVal_int(obj3, &val4);
37927 if (!SWIG_IsOK(ecode4)) {
37928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37929 }
37930 arg4 = static_cast< int >(val4);
37931 }
37932 if (obj4) {
37933 ecode5 = SWIG_AsVal_int(obj4, &val5);
37934 if (!SWIG_IsOK(ecode5)) {
37935 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37936 }
37937 arg5 = static_cast< int >(val5);
37938 }
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 {
37946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37947 }
37948 return resultobj;
37949 fail:
37950 return NULL;
37951 }
37952
37953
37954 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37955 PyObject *resultobj = 0;
37956 wxWindow *arg1 = (wxWindow *) 0 ;
37957 wxPoint *arg2 = 0 ;
37958 bool result;
37959 void *argp1 = 0 ;
37960 int res1 = 0 ;
37961 wxPoint temp2 ;
37962 PyObject * obj0 = 0 ;
37963 PyObject * obj1 = 0 ;
37964 char * kwnames[] = {
37965 (char *) "self",(char *) "pt", NULL
37966 };
37967
37968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37970 if (!SWIG_IsOK(res1)) {
37971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37972 }
37973 arg1 = reinterpret_cast< wxWindow * >(argp1);
37974 {
37975 arg2 = &temp2;
37976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37977 }
37978 {
37979 PyThreadState* __tstate = wxPyBeginAllowThreads();
37980 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37981 wxPyEndAllowThreads(__tstate);
37982 if (PyErr_Occurred()) SWIG_fail;
37983 }
37984 {
37985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37986 }
37987 return resultobj;
37988 fail:
37989 return NULL;
37990 }
37991
37992
37993 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37994 PyObject *resultobj = 0;
37995 wxWindow *arg1 = (wxWindow *) 0 ;
37996 wxRect *arg2 = 0 ;
37997 bool result;
37998 void *argp1 = 0 ;
37999 int res1 = 0 ;
38000 wxRect temp2 ;
38001 PyObject * obj0 = 0 ;
38002 PyObject * obj1 = 0 ;
38003 char * kwnames[] = {
38004 (char *) "self",(char *) "rect", NULL
38005 };
38006
38007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38009 if (!SWIG_IsOK(res1)) {
38010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38011 }
38012 arg1 = reinterpret_cast< wxWindow * >(argp1);
38013 {
38014 arg2 = &temp2;
38015 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38016 }
38017 {
38018 PyThreadState* __tstate = wxPyBeginAllowThreads();
38019 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38020 wxPyEndAllowThreads(__tstate);
38021 if (PyErr_Occurred()) SWIG_fail;
38022 }
38023 {
38024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38025 }
38026 return resultobj;
38027 fail:
38028 return NULL;
38029 }
38030
38031
38032 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38033 PyObject *resultobj = 0;
38034 wxWindow *arg1 = (wxWindow *) 0 ;
38035 SwigValueWrapper<wxVisualAttributes > result;
38036 void *argp1 = 0 ;
38037 int res1 = 0 ;
38038 PyObject *swig_obj[1] ;
38039
38040 if (!args) SWIG_fail;
38041 swig_obj[0] = args;
38042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38043 if (!SWIG_IsOK(res1)) {
38044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38045 }
38046 arg1 = reinterpret_cast< wxWindow * >(argp1);
38047 {
38048 PyThreadState* __tstate = wxPyBeginAllowThreads();
38049 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38050 wxPyEndAllowThreads(__tstate);
38051 if (PyErr_Occurred()) SWIG_fail;
38052 }
38053 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38054 return resultobj;
38055 fail:
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38063 SwigValueWrapper<wxVisualAttributes > result;
38064 int val1 ;
38065 int ecode1 = 0 ;
38066 PyObject * obj0 = 0 ;
38067 char * kwnames[] = {
38068 (char *) "variant", NULL
38069 };
38070
38071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38072 if (obj0) {
38073 ecode1 = SWIG_AsVal_int(obj0, &val1);
38074 if (!SWIG_IsOK(ecode1)) {
38075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38076 }
38077 arg1 = static_cast< wxWindowVariant >(val1);
38078 }
38079 {
38080 if (!wxPyCheckForApp()) SWIG_fail;
38081 PyThreadState* __tstate = wxPyBeginAllowThreads();
38082 result = wxWindow::GetClassDefaultAttributes(arg1);
38083 wxPyEndAllowThreads(__tstate);
38084 if (PyErr_Occurred()) SWIG_fail;
38085 }
38086 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 wxColour *arg2 = 0 ;
38097 bool result;
38098 void *argp1 = 0 ;
38099 int res1 = 0 ;
38100 wxColour temp2 ;
38101 PyObject * obj0 = 0 ;
38102 PyObject * obj1 = 0 ;
38103 char * kwnames[] = {
38104 (char *) "self",(char *) "colour", NULL
38105 };
38106
38107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38109 if (!SWIG_IsOK(res1)) {
38110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38111 }
38112 arg1 = reinterpret_cast< wxWindow * >(argp1);
38113 {
38114 arg2 = &temp2;
38115 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38116 }
38117 {
38118 PyThreadState* __tstate = wxPyBeginAllowThreads();
38119 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38120 wxPyEndAllowThreads(__tstate);
38121 if (PyErr_Occurred()) SWIG_fail;
38122 }
38123 {
38124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj = 0;
38134 wxWindow *arg1 = (wxWindow *) 0 ;
38135 wxColour *arg2 = 0 ;
38136 void *argp1 = 0 ;
38137 int res1 = 0 ;
38138 wxColour temp2 ;
38139 PyObject * obj0 = 0 ;
38140 PyObject * obj1 = 0 ;
38141 char * kwnames[] = {
38142 (char *) "self",(char *) "colour", NULL
38143 };
38144
38145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38147 if (!SWIG_IsOK(res1)) {
38148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38149 }
38150 arg1 = reinterpret_cast< wxWindow * >(argp1);
38151 {
38152 arg2 = &temp2;
38153 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38154 }
38155 {
38156 PyThreadState* __tstate = wxPyBeginAllowThreads();
38157 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38158 wxPyEndAllowThreads(__tstate);
38159 if (PyErr_Occurred()) SWIG_fail;
38160 }
38161 resultobj = SWIG_Py_Void();
38162 return resultobj;
38163 fail:
38164 return NULL;
38165 }
38166
38167
38168 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38169 PyObject *resultobj = 0;
38170 wxWindow *arg1 = (wxWindow *) 0 ;
38171 wxColour *arg2 = 0 ;
38172 bool result;
38173 void *argp1 = 0 ;
38174 int res1 = 0 ;
38175 wxColour temp2 ;
38176 PyObject * obj0 = 0 ;
38177 PyObject * obj1 = 0 ;
38178 char * kwnames[] = {
38179 (char *) "self",(char *) "colour", NULL
38180 };
38181
38182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38184 if (!SWIG_IsOK(res1)) {
38185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38186 }
38187 arg1 = reinterpret_cast< wxWindow * >(argp1);
38188 {
38189 arg2 = &temp2;
38190 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38191 }
38192 {
38193 PyThreadState* __tstate = wxPyBeginAllowThreads();
38194 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38195 wxPyEndAllowThreads(__tstate);
38196 if (PyErr_Occurred()) SWIG_fail;
38197 }
38198 {
38199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38200 }
38201 return resultobj;
38202 fail:
38203 return NULL;
38204 }
38205
38206
38207 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj = 0;
38209 wxWindow *arg1 = (wxWindow *) 0 ;
38210 wxColour *arg2 = 0 ;
38211 void *argp1 = 0 ;
38212 int res1 = 0 ;
38213 wxColour temp2 ;
38214 PyObject * obj0 = 0 ;
38215 PyObject * obj1 = 0 ;
38216 char * kwnames[] = {
38217 (char *) "self",(char *) "colour", NULL
38218 };
38219
38220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38222 if (!SWIG_IsOK(res1)) {
38223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38224 }
38225 arg1 = reinterpret_cast< wxWindow * >(argp1);
38226 {
38227 arg2 = &temp2;
38228 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38229 }
38230 {
38231 PyThreadState* __tstate = wxPyBeginAllowThreads();
38232 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38233 wxPyEndAllowThreads(__tstate);
38234 if (PyErr_Occurred()) SWIG_fail;
38235 }
38236 resultobj = SWIG_Py_Void();
38237 return resultobj;
38238 fail:
38239 return NULL;
38240 }
38241
38242
38243 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38244 PyObject *resultobj = 0;
38245 wxWindow *arg1 = (wxWindow *) 0 ;
38246 wxColour result;
38247 void *argp1 = 0 ;
38248 int res1 = 0 ;
38249 PyObject *swig_obj[1] ;
38250
38251 if (!args) SWIG_fail;
38252 swig_obj[0] = args;
38253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38254 if (!SWIG_IsOK(res1)) {
38255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38256 }
38257 arg1 = reinterpret_cast< wxWindow * >(argp1);
38258 {
38259 PyThreadState* __tstate = wxPyBeginAllowThreads();
38260 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38265 return resultobj;
38266 fail:
38267 return NULL;
38268 }
38269
38270
38271 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38272 PyObject *resultobj = 0;
38273 wxWindow *arg1 = (wxWindow *) 0 ;
38274 wxColour result;
38275 void *argp1 = 0 ;
38276 int res1 = 0 ;
38277 PyObject *swig_obj[1] ;
38278
38279 if (!args) SWIG_fail;
38280 swig_obj[0] = args;
38281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38282 if (!SWIG_IsOK(res1)) {
38283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38284 }
38285 arg1 = reinterpret_cast< wxWindow * >(argp1);
38286 {
38287 PyThreadState* __tstate = wxPyBeginAllowThreads();
38288 result = ((wxWindow const *)arg1)->GetForegroundColour();
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38293 return resultobj;
38294 fail:
38295 return NULL;
38296 }
38297
38298
38299 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38300 PyObject *resultobj = 0;
38301 wxWindow *arg1 = (wxWindow *) 0 ;
38302 bool result;
38303 void *argp1 = 0 ;
38304 int res1 = 0 ;
38305 PyObject *swig_obj[1] ;
38306
38307 if (!args) SWIG_fail;
38308 swig_obj[0] = args;
38309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38310 if (!SWIG_IsOK(res1)) {
38311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38312 }
38313 arg1 = reinterpret_cast< wxWindow * >(argp1);
38314 {
38315 PyThreadState* __tstate = wxPyBeginAllowThreads();
38316 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38317 wxPyEndAllowThreads(__tstate);
38318 if (PyErr_Occurred()) SWIG_fail;
38319 }
38320 {
38321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38322 }
38323 return resultobj;
38324 fail:
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38330 PyObject *resultobj = 0;
38331 wxWindow *arg1 = (wxWindow *) 0 ;
38332 bool result;
38333 void *argp1 = 0 ;
38334 int res1 = 0 ;
38335 PyObject *swig_obj[1] ;
38336
38337 if (!args) SWIG_fail;
38338 swig_obj[0] = args;
38339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38340 if (!SWIG_IsOK(res1)) {
38341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38342 }
38343 arg1 = reinterpret_cast< wxWindow * >(argp1);
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 {
38351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38352 }
38353 return resultobj;
38354 fail:
38355 return NULL;
38356 }
38357
38358
38359 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38360 PyObject *resultobj = 0;
38361 wxWindow *arg1 = (wxWindow *) 0 ;
38362 wxBackgroundStyle arg2 ;
38363 bool result;
38364 void *argp1 = 0 ;
38365 int res1 = 0 ;
38366 int val2 ;
38367 int ecode2 = 0 ;
38368 PyObject * obj0 = 0 ;
38369 PyObject * obj1 = 0 ;
38370 char * kwnames[] = {
38371 (char *) "self",(char *) "style", NULL
38372 };
38373
38374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38376 if (!SWIG_IsOK(res1)) {
38377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38378 }
38379 arg1 = reinterpret_cast< wxWindow * >(argp1);
38380 ecode2 = SWIG_AsVal_int(obj1, &val2);
38381 if (!SWIG_IsOK(ecode2)) {
38382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38383 }
38384 arg2 = static_cast< wxBackgroundStyle >(val2);
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 {
38392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38393 }
38394 return resultobj;
38395 fail:
38396 return NULL;
38397 }
38398
38399
38400 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38401 PyObject *resultobj = 0;
38402 wxWindow *arg1 = (wxWindow *) 0 ;
38403 wxBackgroundStyle result;
38404 void *argp1 = 0 ;
38405 int res1 = 0 ;
38406 PyObject *swig_obj[1] ;
38407
38408 if (!args) SWIG_fail;
38409 swig_obj[0] = args;
38410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38411 if (!SWIG_IsOK(res1)) {
38412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38413 }
38414 arg1 = reinterpret_cast< wxWindow * >(argp1);
38415 {
38416 PyThreadState* __tstate = wxPyBeginAllowThreads();
38417 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38418 wxPyEndAllowThreads(__tstate);
38419 if (PyErr_Occurred()) SWIG_fail;
38420 }
38421 resultobj = SWIG_From_int(static_cast< int >(result));
38422 return resultobj;
38423 fail:
38424 return NULL;
38425 }
38426
38427
38428 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38429 PyObject *resultobj = 0;
38430 wxWindow *arg1 = (wxWindow *) 0 ;
38431 bool result;
38432 void *argp1 = 0 ;
38433 int res1 = 0 ;
38434 PyObject *swig_obj[1] ;
38435
38436 if (!args) SWIG_fail;
38437 swig_obj[0] = args;
38438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38439 if (!SWIG_IsOK(res1)) {
38440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38441 }
38442 arg1 = reinterpret_cast< wxWindow * >(argp1);
38443 {
38444 PyThreadState* __tstate = wxPyBeginAllowThreads();
38445 result = (bool)(arg1)->HasTransparentBackground();
38446 wxPyEndAllowThreads(__tstate);
38447 if (PyErr_Occurred()) SWIG_fail;
38448 }
38449 {
38450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38451 }
38452 return resultobj;
38453 fail:
38454 return NULL;
38455 }
38456
38457
38458 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38459 PyObject *resultobj = 0;
38460 wxWindow *arg1 = (wxWindow *) 0 ;
38461 wxCursor *arg2 = 0 ;
38462 bool result;
38463 void *argp1 = 0 ;
38464 int res1 = 0 ;
38465 void *argp2 = 0 ;
38466 int res2 = 0 ;
38467 PyObject * obj0 = 0 ;
38468 PyObject * obj1 = 0 ;
38469 char * kwnames[] = {
38470 (char *) "self",(char *) "cursor", NULL
38471 };
38472
38473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38475 if (!SWIG_IsOK(res1)) {
38476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38477 }
38478 arg1 = reinterpret_cast< wxWindow * >(argp1);
38479 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38480 if (!SWIG_IsOK(res2)) {
38481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38482 }
38483 if (!argp2) {
38484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38485 }
38486 arg2 = reinterpret_cast< wxCursor * >(argp2);
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38490 wxPyEndAllowThreads(__tstate);
38491 if (PyErr_Occurred()) SWIG_fail;
38492 }
38493 {
38494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38495 }
38496 return resultobj;
38497 fail:
38498 return NULL;
38499 }
38500
38501
38502 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38503 PyObject *resultobj = 0;
38504 wxWindow *arg1 = (wxWindow *) 0 ;
38505 wxCursor result;
38506 void *argp1 = 0 ;
38507 int res1 = 0 ;
38508 PyObject *swig_obj[1] ;
38509
38510 if (!args) SWIG_fail;
38511 swig_obj[0] = args;
38512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38513 if (!SWIG_IsOK(res1)) {
38514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38515 }
38516 arg1 = reinterpret_cast< wxWindow * >(argp1);
38517 {
38518 PyThreadState* __tstate = wxPyBeginAllowThreads();
38519 result = (arg1)->GetCursor();
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38524 return resultobj;
38525 fail:
38526 return NULL;
38527 }
38528
38529
38530 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38531 PyObject *resultobj = 0;
38532 wxWindow *arg1 = (wxWindow *) 0 ;
38533 wxFont *arg2 = 0 ;
38534 bool result;
38535 void *argp1 = 0 ;
38536 int res1 = 0 ;
38537 void *argp2 = 0 ;
38538 int res2 = 0 ;
38539 PyObject * obj0 = 0 ;
38540 PyObject * obj1 = 0 ;
38541 char * kwnames[] = {
38542 (char *) "self",(char *) "font", NULL
38543 };
38544
38545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38547 if (!SWIG_IsOK(res1)) {
38548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38549 }
38550 arg1 = reinterpret_cast< wxWindow * >(argp1);
38551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38552 if (!SWIG_IsOK(res2)) {
38553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38554 }
38555 if (!argp2) {
38556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38557 }
38558 arg2 = reinterpret_cast< wxFont * >(argp2);
38559 {
38560 PyThreadState* __tstate = wxPyBeginAllowThreads();
38561 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38562 wxPyEndAllowThreads(__tstate);
38563 if (PyErr_Occurred()) SWIG_fail;
38564 }
38565 {
38566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38567 }
38568 return resultobj;
38569 fail:
38570 return NULL;
38571 }
38572
38573
38574 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38575 PyObject *resultobj = 0;
38576 wxWindow *arg1 = (wxWindow *) 0 ;
38577 wxFont *arg2 = 0 ;
38578 void *argp1 = 0 ;
38579 int res1 = 0 ;
38580 void *argp2 = 0 ;
38581 int res2 = 0 ;
38582 PyObject * obj0 = 0 ;
38583 PyObject * obj1 = 0 ;
38584 char * kwnames[] = {
38585 (char *) "self",(char *) "font", NULL
38586 };
38587
38588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38590 if (!SWIG_IsOK(res1)) {
38591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38592 }
38593 arg1 = reinterpret_cast< wxWindow * >(argp1);
38594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38595 if (!SWIG_IsOK(res2)) {
38596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38597 }
38598 if (!argp2) {
38599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38600 }
38601 arg2 = reinterpret_cast< wxFont * >(argp2);
38602 {
38603 PyThreadState* __tstate = wxPyBeginAllowThreads();
38604 (arg1)->SetOwnFont((wxFont const &)*arg2);
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 resultobj = SWIG_Py_Void();
38609 return resultobj;
38610 fail:
38611 return NULL;
38612 }
38613
38614
38615 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38616 PyObject *resultobj = 0;
38617 wxWindow *arg1 = (wxWindow *) 0 ;
38618 wxFont result;
38619 void *argp1 = 0 ;
38620 int res1 = 0 ;
38621 PyObject *swig_obj[1] ;
38622
38623 if (!args) SWIG_fail;
38624 swig_obj[0] = args;
38625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38628 }
38629 arg1 = reinterpret_cast< wxWindow * >(argp1);
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 result = (arg1)->GetFont();
38633 wxPyEndAllowThreads(__tstate);
38634 if (PyErr_Occurred()) SWIG_fail;
38635 }
38636 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38637 return resultobj;
38638 fail:
38639 return NULL;
38640 }
38641
38642
38643 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38644 PyObject *resultobj = 0;
38645 wxWindow *arg1 = (wxWindow *) 0 ;
38646 wxCaret *arg2 = (wxCaret *) 0 ;
38647 void *argp1 = 0 ;
38648 int res1 = 0 ;
38649 int res2 = 0 ;
38650 PyObject * obj0 = 0 ;
38651 PyObject * obj1 = 0 ;
38652 char * kwnames[] = {
38653 (char *) "self",(char *) "caret", NULL
38654 };
38655
38656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38658 if (!SWIG_IsOK(res1)) {
38659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38660 }
38661 arg1 = reinterpret_cast< wxWindow * >(argp1);
38662 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38663 if (!SWIG_IsOK(res2)) {
38664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38665 }
38666 {
38667 PyThreadState* __tstate = wxPyBeginAllowThreads();
38668 (arg1)->SetCaret(arg2);
38669 wxPyEndAllowThreads(__tstate);
38670 if (PyErr_Occurred()) SWIG_fail;
38671 }
38672 resultobj = SWIG_Py_Void();
38673 return resultobj;
38674 fail:
38675 return NULL;
38676 }
38677
38678
38679 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38680 PyObject *resultobj = 0;
38681 wxWindow *arg1 = (wxWindow *) 0 ;
38682 wxCaret *result = 0 ;
38683 void *argp1 = 0 ;
38684 int res1 = 0 ;
38685 PyObject *swig_obj[1] ;
38686
38687 if (!args) SWIG_fail;
38688 swig_obj[0] = args;
38689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38690 if (!SWIG_IsOK(res1)) {
38691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38692 }
38693 arg1 = reinterpret_cast< wxWindow * >(argp1);
38694 {
38695 PyThreadState* __tstate = wxPyBeginAllowThreads();
38696 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38701 return resultobj;
38702 fail:
38703 return NULL;
38704 }
38705
38706
38707 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38708 PyObject *resultobj = 0;
38709 wxWindow *arg1 = (wxWindow *) 0 ;
38710 int result;
38711 void *argp1 = 0 ;
38712 int res1 = 0 ;
38713 PyObject *swig_obj[1] ;
38714
38715 if (!args) SWIG_fail;
38716 swig_obj[0] = args;
38717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38718 if (!SWIG_IsOK(res1)) {
38719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38720 }
38721 arg1 = reinterpret_cast< wxWindow * >(argp1);
38722 {
38723 PyThreadState* __tstate = wxPyBeginAllowThreads();
38724 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38725 wxPyEndAllowThreads(__tstate);
38726 if (PyErr_Occurred()) SWIG_fail;
38727 }
38728 resultobj = SWIG_From_int(static_cast< int >(result));
38729 return resultobj;
38730 fail:
38731 return NULL;
38732 }
38733
38734
38735 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38736 PyObject *resultobj = 0;
38737 wxWindow *arg1 = (wxWindow *) 0 ;
38738 int result;
38739 void *argp1 = 0 ;
38740 int res1 = 0 ;
38741 PyObject *swig_obj[1] ;
38742
38743 if (!args) SWIG_fail;
38744 swig_obj[0] = args;
38745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38746 if (!SWIG_IsOK(res1)) {
38747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38748 }
38749 arg1 = reinterpret_cast< wxWindow * >(argp1);
38750 {
38751 PyThreadState* __tstate = wxPyBeginAllowThreads();
38752 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38753 wxPyEndAllowThreads(__tstate);
38754 if (PyErr_Occurred()) SWIG_fail;
38755 }
38756 resultobj = SWIG_From_int(static_cast< int >(result));
38757 return resultobj;
38758 fail:
38759 return NULL;
38760 }
38761
38762
38763 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38764 PyObject *resultobj = 0;
38765 wxWindow *arg1 = (wxWindow *) 0 ;
38766 wxString *arg2 = 0 ;
38767 int *arg3 = (int *) 0 ;
38768 int *arg4 = (int *) 0 ;
38769 void *argp1 = 0 ;
38770 int res1 = 0 ;
38771 bool temp2 = false ;
38772 int temp3 ;
38773 int res3 = SWIG_TMPOBJ ;
38774 int temp4 ;
38775 int res4 = SWIG_TMPOBJ ;
38776 PyObject * obj0 = 0 ;
38777 PyObject * obj1 = 0 ;
38778 char * kwnames[] = {
38779 (char *) "self",(char *) "string", NULL
38780 };
38781
38782 arg3 = &temp3;
38783 arg4 = &temp4;
38784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38786 if (!SWIG_IsOK(res1)) {
38787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38788 }
38789 arg1 = reinterpret_cast< wxWindow * >(argp1);
38790 {
38791 arg2 = wxString_in_helper(obj1);
38792 if (arg2 == NULL) SWIG_fail;
38793 temp2 = true;
38794 }
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 resultobj = SWIG_Py_Void();
38802 if (SWIG_IsTmpObj(res3)) {
38803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38804 } else {
38805 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38807 }
38808 if (SWIG_IsTmpObj(res4)) {
38809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38810 } else {
38811 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38813 }
38814 {
38815 if (temp2)
38816 delete arg2;
38817 }
38818 return resultobj;
38819 fail:
38820 {
38821 if (temp2)
38822 delete arg2;
38823 }
38824 return NULL;
38825 }
38826
38827
38828 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38829 PyObject *resultobj = 0;
38830 wxWindow *arg1 = (wxWindow *) 0 ;
38831 wxString *arg2 = 0 ;
38832 int *arg3 = (int *) 0 ;
38833 int *arg4 = (int *) 0 ;
38834 int *arg5 = (int *) 0 ;
38835 int *arg6 = (int *) 0 ;
38836 wxFont *arg7 = (wxFont *) NULL ;
38837 void *argp1 = 0 ;
38838 int res1 = 0 ;
38839 bool temp2 = false ;
38840 int temp3 ;
38841 int res3 = SWIG_TMPOBJ ;
38842 int temp4 ;
38843 int res4 = SWIG_TMPOBJ ;
38844 int temp5 ;
38845 int res5 = SWIG_TMPOBJ ;
38846 int temp6 ;
38847 int res6 = SWIG_TMPOBJ ;
38848 void *argp7 = 0 ;
38849 int res7 = 0 ;
38850 PyObject * obj0 = 0 ;
38851 PyObject * obj1 = 0 ;
38852 PyObject * obj2 = 0 ;
38853 char * kwnames[] = {
38854 (char *) "self",(char *) "string",(char *) "font", NULL
38855 };
38856
38857 arg3 = &temp3;
38858 arg4 = &temp4;
38859 arg5 = &temp5;
38860 arg6 = &temp6;
38861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38863 if (!SWIG_IsOK(res1)) {
38864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38865 }
38866 arg1 = reinterpret_cast< wxWindow * >(argp1);
38867 {
38868 arg2 = wxString_in_helper(obj1);
38869 if (arg2 == NULL) SWIG_fail;
38870 temp2 = true;
38871 }
38872 if (obj2) {
38873 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38874 if (!SWIG_IsOK(res7)) {
38875 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38876 }
38877 arg7 = reinterpret_cast< wxFont * >(argp7);
38878 }
38879 {
38880 PyThreadState* __tstate = wxPyBeginAllowThreads();
38881 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38882 wxPyEndAllowThreads(__tstate);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 }
38885 resultobj = SWIG_Py_Void();
38886 if (SWIG_IsTmpObj(res3)) {
38887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38888 } else {
38889 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38891 }
38892 if (SWIG_IsTmpObj(res4)) {
38893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38894 } else {
38895 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38897 }
38898 if (SWIG_IsTmpObj(res5)) {
38899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38900 } else {
38901 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38903 }
38904 if (SWIG_IsTmpObj(res6)) {
38905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38906 } else {
38907 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38909 }
38910 {
38911 if (temp2)
38912 delete arg2;
38913 }
38914 return resultobj;
38915 fail:
38916 {
38917 if (temp2)
38918 delete arg2;
38919 }
38920 return NULL;
38921 }
38922
38923
38924 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38925 PyObject *resultobj = 0;
38926 wxWindow *arg1 = (wxWindow *) 0 ;
38927 int *arg2 = (int *) 0 ;
38928 int *arg3 = (int *) 0 ;
38929 void *argp1 = 0 ;
38930 int res1 = 0 ;
38931 int temp2 ;
38932 int res2 = 0 ;
38933 int temp3 ;
38934 int res3 = 0 ;
38935 PyObject * obj0 = 0 ;
38936 PyObject * obj1 = 0 ;
38937 PyObject * obj2 = 0 ;
38938 char * kwnames[] = {
38939 (char *) "self",(char *) "x",(char *) "y", NULL
38940 };
38941
38942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38944 if (!SWIG_IsOK(res1)) {
38945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38946 }
38947 arg1 = reinterpret_cast< wxWindow * >(argp1);
38948 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38949 int val;
38950 int ecode = SWIG_AsVal_int(obj1, &val);
38951 if (!SWIG_IsOK(ecode)) {
38952 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38953 }
38954 temp2 = static_cast< int >(val);
38955 arg2 = &temp2;
38956 res2 = SWIG_AddTmpMask(ecode);
38957 }
38958 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38959 int val;
38960 int ecode = SWIG_AsVal_int(obj2, &val);
38961 if (!SWIG_IsOK(ecode)) {
38962 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38963 }
38964 temp3 = static_cast< int >(val);
38965 arg3 = &temp3;
38966 res3 = SWIG_AddTmpMask(ecode);
38967 }
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 resultobj = SWIG_Py_Void();
38975 if (SWIG_IsTmpObj(res2)) {
38976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38977 } else {
38978 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38980 }
38981 if (SWIG_IsTmpObj(res3)) {
38982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38983 } else {
38984 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38986 }
38987 return resultobj;
38988 fail:
38989 return NULL;
38990 }
38991
38992
38993 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38994 PyObject *resultobj = 0;
38995 wxWindow *arg1 = (wxWindow *) 0 ;
38996 int *arg2 = (int *) 0 ;
38997 int *arg3 = (int *) 0 ;
38998 void *argp1 = 0 ;
38999 int res1 = 0 ;
39000 int temp2 ;
39001 int res2 = 0 ;
39002 int temp3 ;
39003 int res3 = 0 ;
39004 PyObject * obj0 = 0 ;
39005 PyObject * obj1 = 0 ;
39006 PyObject * obj2 = 0 ;
39007 char * kwnames[] = {
39008 (char *) "self",(char *) "x",(char *) "y", NULL
39009 };
39010
39011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39013 if (!SWIG_IsOK(res1)) {
39014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39015 }
39016 arg1 = reinterpret_cast< wxWindow * >(argp1);
39017 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39018 int val;
39019 int ecode = SWIG_AsVal_int(obj1, &val);
39020 if (!SWIG_IsOK(ecode)) {
39021 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39022 }
39023 temp2 = static_cast< int >(val);
39024 arg2 = &temp2;
39025 res2 = SWIG_AddTmpMask(ecode);
39026 }
39027 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39028 int val;
39029 int ecode = SWIG_AsVal_int(obj2, &val);
39030 if (!SWIG_IsOK(ecode)) {
39031 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39032 }
39033 temp3 = static_cast< int >(val);
39034 arg3 = &temp3;
39035 res3 = SWIG_AddTmpMask(ecode);
39036 }
39037 {
39038 PyThreadState* __tstate = wxPyBeginAllowThreads();
39039 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 resultobj = SWIG_Py_Void();
39044 if (SWIG_IsTmpObj(res2)) {
39045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39046 } else {
39047 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39049 }
39050 if (SWIG_IsTmpObj(res3)) {
39051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39052 } else {
39053 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39055 }
39056 return resultobj;
39057 fail:
39058 return NULL;
39059 }
39060
39061
39062 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39063 PyObject *resultobj = 0;
39064 wxWindow *arg1 = (wxWindow *) 0 ;
39065 wxPoint *arg2 = 0 ;
39066 wxPoint result;
39067 void *argp1 = 0 ;
39068 int res1 = 0 ;
39069 wxPoint temp2 ;
39070 PyObject * obj0 = 0 ;
39071 PyObject * obj1 = 0 ;
39072 char * kwnames[] = {
39073 (char *) "self",(char *) "pt", NULL
39074 };
39075
39076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39080 }
39081 arg1 = reinterpret_cast< wxWindow * >(argp1);
39082 {
39083 arg2 = &temp2;
39084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39085 }
39086 {
39087 PyThreadState* __tstate = wxPyBeginAllowThreads();
39088 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39089 wxPyEndAllowThreads(__tstate);
39090 if (PyErr_Occurred()) SWIG_fail;
39091 }
39092 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39093 return resultobj;
39094 fail:
39095 return NULL;
39096 }
39097
39098
39099 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39100 PyObject *resultobj = 0;
39101 wxWindow *arg1 = (wxWindow *) 0 ;
39102 wxPoint *arg2 = 0 ;
39103 wxPoint result;
39104 void *argp1 = 0 ;
39105 int res1 = 0 ;
39106 wxPoint temp2 ;
39107 PyObject * obj0 = 0 ;
39108 PyObject * obj1 = 0 ;
39109 char * kwnames[] = {
39110 (char *) "self",(char *) "pt", NULL
39111 };
39112
39113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39115 if (!SWIG_IsOK(res1)) {
39116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39117 }
39118 arg1 = reinterpret_cast< wxWindow * >(argp1);
39119 {
39120 arg2 = &temp2;
39121 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39122 }
39123 {
39124 PyThreadState* __tstate = wxPyBeginAllowThreads();
39125 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39126 wxPyEndAllowThreads(__tstate);
39127 if (PyErr_Occurred()) SWIG_fail;
39128 }
39129 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39130 return resultobj;
39131 fail:
39132 return NULL;
39133 }
39134
39135
39136 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39137 PyObject *resultobj = 0;
39138 wxWindow *arg1 = (wxWindow *) 0 ;
39139 int arg2 ;
39140 int arg3 ;
39141 wxHitTest result;
39142 void *argp1 = 0 ;
39143 int res1 = 0 ;
39144 int val2 ;
39145 int ecode2 = 0 ;
39146 int val3 ;
39147 int ecode3 = 0 ;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 PyObject * obj2 = 0 ;
39151 char * kwnames[] = {
39152 (char *) "self",(char *) "x",(char *) "y", NULL
39153 };
39154
39155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39157 if (!SWIG_IsOK(res1)) {
39158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39159 }
39160 arg1 = reinterpret_cast< wxWindow * >(argp1);
39161 ecode2 = SWIG_AsVal_int(obj1, &val2);
39162 if (!SWIG_IsOK(ecode2)) {
39163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39164 }
39165 arg2 = static_cast< int >(val2);
39166 ecode3 = SWIG_AsVal_int(obj2, &val3);
39167 if (!SWIG_IsOK(ecode3)) {
39168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39169 }
39170 arg3 = static_cast< int >(val3);
39171 {
39172 PyThreadState* __tstate = wxPyBeginAllowThreads();
39173 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39174 wxPyEndAllowThreads(__tstate);
39175 if (PyErr_Occurred()) SWIG_fail;
39176 }
39177 resultobj = SWIG_From_int(static_cast< int >(result));
39178 return resultobj;
39179 fail:
39180 return NULL;
39181 }
39182
39183
39184 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39185 PyObject *resultobj = 0;
39186 wxWindow *arg1 = (wxWindow *) 0 ;
39187 wxPoint *arg2 = 0 ;
39188 wxHitTest result;
39189 void *argp1 = 0 ;
39190 int res1 = 0 ;
39191 wxPoint temp2 ;
39192 PyObject * obj0 = 0 ;
39193 PyObject * obj1 = 0 ;
39194 char * kwnames[] = {
39195 (char *) "self",(char *) "pt", NULL
39196 };
39197
39198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39200 if (!SWIG_IsOK(res1)) {
39201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39202 }
39203 arg1 = reinterpret_cast< wxWindow * >(argp1);
39204 {
39205 arg2 = &temp2;
39206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39207 }
39208 {
39209 PyThreadState* __tstate = wxPyBeginAllowThreads();
39210 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39211 wxPyEndAllowThreads(__tstate);
39212 if (PyErr_Occurred()) SWIG_fail;
39213 }
39214 resultobj = SWIG_From_int(static_cast< int >(result));
39215 return resultobj;
39216 fail:
39217 return NULL;
39218 }
39219
39220
39221 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39222 PyObject *resultobj = 0;
39223 wxWindow *arg1 = (wxWindow *) 0 ;
39224 long arg2 ;
39225 wxBorder result;
39226 void *argp1 = 0 ;
39227 int res1 = 0 ;
39228 long val2 ;
39229 int ecode2 = 0 ;
39230
39231 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39233 if (!SWIG_IsOK(res1)) {
39234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39235 }
39236 arg1 = reinterpret_cast< wxWindow * >(argp1);
39237 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39238 if (!SWIG_IsOK(ecode2)) {
39239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39240 }
39241 arg2 = static_cast< long >(val2);
39242 {
39243 PyThreadState* __tstate = wxPyBeginAllowThreads();
39244 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39245 wxPyEndAllowThreads(__tstate);
39246 if (PyErr_Occurred()) SWIG_fail;
39247 }
39248 resultobj = SWIG_From_int(static_cast< int >(result));
39249 return resultobj;
39250 fail:
39251 return NULL;
39252 }
39253
39254
39255 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39256 PyObject *resultobj = 0;
39257 wxWindow *arg1 = (wxWindow *) 0 ;
39258 wxBorder result;
39259 void *argp1 = 0 ;
39260 int res1 = 0 ;
39261
39262 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39264 if (!SWIG_IsOK(res1)) {
39265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39266 }
39267 arg1 = reinterpret_cast< wxWindow * >(argp1);
39268 {
39269 PyThreadState* __tstate = wxPyBeginAllowThreads();
39270 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39271 wxPyEndAllowThreads(__tstate);
39272 if (PyErr_Occurred()) SWIG_fail;
39273 }
39274 resultobj = SWIG_From_int(static_cast< int >(result));
39275 return resultobj;
39276 fail:
39277 return NULL;
39278 }
39279
39280
39281 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39282 int argc;
39283 PyObject *argv[3];
39284
39285 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39286 --argc;
39287 if (argc == 1) {
39288 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39289 }
39290 if (argc == 2) {
39291 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39292 }
39293
39294 fail:
39295 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39296 return NULL;
39297 }
39298
39299
39300 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39301 PyObject *resultobj = 0;
39302 wxWindow *arg1 = (wxWindow *) 0 ;
39303 long arg2 = (long) wxUPDATE_UI_NONE ;
39304 void *argp1 = 0 ;
39305 int res1 = 0 ;
39306 long val2 ;
39307 int ecode2 = 0 ;
39308 PyObject * obj0 = 0 ;
39309 PyObject * obj1 = 0 ;
39310 char * kwnames[] = {
39311 (char *) "self",(char *) "flags", NULL
39312 };
39313
39314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39316 if (!SWIG_IsOK(res1)) {
39317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39318 }
39319 arg1 = reinterpret_cast< wxWindow * >(argp1);
39320 if (obj1) {
39321 ecode2 = SWIG_AsVal_long(obj1, &val2);
39322 if (!SWIG_IsOK(ecode2)) {
39323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39324 }
39325 arg2 = static_cast< long >(val2);
39326 }
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 (arg1)->UpdateWindowUI(arg2);
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 resultobj = SWIG_Py_Void();
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj = 0;
39342 wxWindow *arg1 = (wxWindow *) 0 ;
39343 wxMenu *arg2 = (wxMenu *) 0 ;
39344 int arg3 = (int) -1 ;
39345 int arg4 = (int) -1 ;
39346 bool result;
39347 void *argp1 = 0 ;
39348 int res1 = 0 ;
39349 void *argp2 = 0 ;
39350 int res2 = 0 ;
39351 int val3 ;
39352 int ecode3 = 0 ;
39353 int val4 ;
39354 int ecode4 = 0 ;
39355 PyObject * obj0 = 0 ;
39356 PyObject * obj1 = 0 ;
39357 PyObject * obj2 = 0 ;
39358 PyObject * obj3 = 0 ;
39359 char * kwnames[] = {
39360 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39361 };
39362
39363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39365 if (!SWIG_IsOK(res1)) {
39366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39367 }
39368 arg1 = reinterpret_cast< wxWindow * >(argp1);
39369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39370 if (!SWIG_IsOK(res2)) {
39371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39372 }
39373 arg2 = reinterpret_cast< wxMenu * >(argp2);
39374 if (obj2) {
39375 ecode3 = SWIG_AsVal_int(obj2, &val3);
39376 if (!SWIG_IsOK(ecode3)) {
39377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39378 }
39379 arg3 = static_cast< int >(val3);
39380 }
39381 if (obj3) {
39382 ecode4 = SWIG_AsVal_int(obj3, &val4);
39383 if (!SWIG_IsOK(ecode4)) {
39384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39385 }
39386 arg4 = static_cast< int >(val4);
39387 }
39388 {
39389 PyThreadState* __tstate = wxPyBeginAllowThreads();
39390 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39391 wxPyEndAllowThreads(__tstate);
39392 if (PyErr_Occurred()) SWIG_fail;
39393 }
39394 {
39395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39396 }
39397 return resultobj;
39398 fail:
39399 return NULL;
39400 }
39401
39402
39403 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39404 PyObject *resultobj = 0;
39405 wxWindow *arg1 = (wxWindow *) 0 ;
39406 wxMenu *arg2 = (wxMenu *) 0 ;
39407 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39408 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39409 bool result;
39410 void *argp1 = 0 ;
39411 int res1 = 0 ;
39412 void *argp2 = 0 ;
39413 int res2 = 0 ;
39414 wxPoint temp3 ;
39415 PyObject * obj0 = 0 ;
39416 PyObject * obj1 = 0 ;
39417 PyObject * obj2 = 0 ;
39418 char * kwnames[] = {
39419 (char *) "self",(char *) "menu",(char *) "pos", NULL
39420 };
39421
39422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39424 if (!SWIG_IsOK(res1)) {
39425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39426 }
39427 arg1 = reinterpret_cast< wxWindow * >(argp1);
39428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39429 if (!SWIG_IsOK(res2)) {
39430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39431 }
39432 arg2 = reinterpret_cast< wxMenu * >(argp2);
39433 if (obj2) {
39434 {
39435 arg3 = &temp3;
39436 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39437 }
39438 }
39439 {
39440 PyThreadState* __tstate = wxPyBeginAllowThreads();
39441 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39442 wxPyEndAllowThreads(__tstate);
39443 if (PyErr_Occurred()) SWIG_fail;
39444 }
39445 {
39446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39447 }
39448 return resultobj;
39449 fail:
39450 return NULL;
39451 }
39452
39453
39454 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39455 PyObject *resultobj = 0;
39456 wxWindow *arg1 = (wxWindow *) 0 ;
39457 bool result;
39458 void *argp1 = 0 ;
39459 int res1 = 0 ;
39460 PyObject *swig_obj[1] ;
39461
39462 if (!args) SWIG_fail;
39463 swig_obj[0] = args;
39464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39465 if (!SWIG_IsOK(res1)) {
39466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39467 }
39468 arg1 = reinterpret_cast< wxWindow * >(argp1);
39469 {
39470 PyThreadState* __tstate = wxPyBeginAllowThreads();
39471 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 {
39476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39477 }
39478 return resultobj;
39479 fail:
39480 return NULL;
39481 }
39482
39483
39484 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39485 PyObject *resultobj = 0;
39486 wxWindow *arg1 = (wxWindow *) 0 ;
39487 long result;
39488 void *argp1 = 0 ;
39489 int res1 = 0 ;
39490 PyObject *swig_obj[1] ;
39491
39492 if (!args) SWIG_fail;
39493 swig_obj[0] = args;
39494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39495 if (!SWIG_IsOK(res1)) {
39496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39497 }
39498 arg1 = reinterpret_cast< wxWindow * >(argp1);
39499 {
39500 PyThreadState* __tstate = wxPyBeginAllowThreads();
39501 result = (long)wxWindow_GetHandle(arg1);
39502 wxPyEndAllowThreads(__tstate);
39503 if (PyErr_Occurred()) SWIG_fail;
39504 }
39505 resultobj = SWIG_From_long(static_cast< long >(result));
39506 return resultobj;
39507 fail:
39508 return NULL;
39509 }
39510
39511
39512 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39513 PyObject *resultobj = 0;
39514 wxWindow *arg1 = (wxWindow *) 0 ;
39515 long arg2 ;
39516 void *argp1 = 0 ;
39517 int res1 = 0 ;
39518 long val2 ;
39519 int ecode2 = 0 ;
39520 PyObject * obj0 = 0 ;
39521 PyObject * obj1 = 0 ;
39522 char * kwnames[] = {
39523 (char *) "self",(char *) "handle", NULL
39524 };
39525
39526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39528 if (!SWIG_IsOK(res1)) {
39529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39530 }
39531 arg1 = reinterpret_cast< wxWindow * >(argp1);
39532 ecode2 = SWIG_AsVal_long(obj1, &val2);
39533 if (!SWIG_IsOK(ecode2)) {
39534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39535 }
39536 arg2 = static_cast< long >(val2);
39537 {
39538 PyThreadState* __tstate = wxPyBeginAllowThreads();
39539 wxWindow_AssociateHandle(arg1,arg2);
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 resultobj = SWIG_Py_Void();
39544 return resultobj;
39545 fail:
39546 return NULL;
39547 }
39548
39549
39550 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39551 PyObject *resultobj = 0;
39552 wxWindow *arg1 = (wxWindow *) 0 ;
39553 void *argp1 = 0 ;
39554 int res1 = 0 ;
39555 PyObject *swig_obj[1] ;
39556
39557 if (!args) SWIG_fail;
39558 swig_obj[0] = args;
39559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39560 if (!SWIG_IsOK(res1)) {
39561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39562 }
39563 arg1 = reinterpret_cast< wxWindow * >(argp1);
39564 {
39565 PyThreadState* __tstate = wxPyBeginAllowThreads();
39566 (arg1)->DissociateHandle();
39567 wxPyEndAllowThreads(__tstate);
39568 if (PyErr_Occurred()) SWIG_fail;
39569 }
39570 resultobj = SWIG_Py_Void();
39571 return resultobj;
39572 fail:
39573 return NULL;
39574 }
39575
39576
39577 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39578 PyObject *resultobj = 0;
39579 wxWindow *arg1 = (wxWindow *) 0 ;
39580 int arg2 ;
39581 bool result;
39582 void *argp1 = 0 ;
39583 int res1 = 0 ;
39584 int val2 ;
39585 int ecode2 = 0 ;
39586 PyObject * obj0 = 0 ;
39587 PyObject * obj1 = 0 ;
39588 char * kwnames[] = {
39589 (char *) "self",(char *) "orient", NULL
39590 };
39591
39592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39594 if (!SWIG_IsOK(res1)) {
39595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39596 }
39597 arg1 = reinterpret_cast< wxWindow * >(argp1);
39598 ecode2 = SWIG_AsVal_int(obj1, &val2);
39599 if (!SWIG_IsOK(ecode2)) {
39600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39601 }
39602 arg2 = static_cast< int >(val2);
39603 {
39604 PyThreadState* __tstate = wxPyBeginAllowThreads();
39605 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39606 wxPyEndAllowThreads(__tstate);
39607 if (PyErr_Occurred()) SWIG_fail;
39608 }
39609 {
39610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39611 }
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39619 PyObject *resultobj = 0;
39620 wxWindow *arg1 = (wxWindow *) 0 ;
39621 int arg2 ;
39622 int arg3 ;
39623 int arg4 ;
39624 int arg5 ;
39625 bool arg6 = (bool) true ;
39626 void *argp1 = 0 ;
39627 int res1 = 0 ;
39628 int val2 ;
39629 int ecode2 = 0 ;
39630 int val3 ;
39631 int ecode3 = 0 ;
39632 int val4 ;
39633 int ecode4 = 0 ;
39634 int val5 ;
39635 int ecode5 = 0 ;
39636 bool val6 ;
39637 int ecode6 = 0 ;
39638 PyObject * obj0 = 0 ;
39639 PyObject * obj1 = 0 ;
39640 PyObject * obj2 = 0 ;
39641 PyObject * obj3 = 0 ;
39642 PyObject * obj4 = 0 ;
39643 PyObject * obj5 = 0 ;
39644 char * kwnames[] = {
39645 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39646 };
39647
39648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39650 if (!SWIG_IsOK(res1)) {
39651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39652 }
39653 arg1 = reinterpret_cast< wxWindow * >(argp1);
39654 ecode2 = SWIG_AsVal_int(obj1, &val2);
39655 if (!SWIG_IsOK(ecode2)) {
39656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39657 }
39658 arg2 = static_cast< int >(val2);
39659 ecode3 = SWIG_AsVal_int(obj2, &val3);
39660 if (!SWIG_IsOK(ecode3)) {
39661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39662 }
39663 arg3 = static_cast< int >(val3);
39664 ecode4 = SWIG_AsVal_int(obj3, &val4);
39665 if (!SWIG_IsOK(ecode4)) {
39666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39667 }
39668 arg4 = static_cast< int >(val4);
39669 ecode5 = SWIG_AsVal_int(obj4, &val5);
39670 if (!SWIG_IsOK(ecode5)) {
39671 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39672 }
39673 arg5 = static_cast< int >(val5);
39674 if (obj5) {
39675 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39676 if (!SWIG_IsOK(ecode6)) {
39677 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39678 }
39679 arg6 = static_cast< bool >(val6);
39680 }
39681 {
39682 PyThreadState* __tstate = wxPyBeginAllowThreads();
39683 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39684 wxPyEndAllowThreads(__tstate);
39685 if (PyErr_Occurred()) SWIG_fail;
39686 }
39687 resultobj = SWIG_Py_Void();
39688 return resultobj;
39689 fail:
39690 return NULL;
39691 }
39692
39693
39694 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39695 PyObject *resultobj = 0;
39696 wxWindow *arg1 = (wxWindow *) 0 ;
39697 int arg2 ;
39698 int arg3 ;
39699 bool arg4 = (bool) true ;
39700 void *argp1 = 0 ;
39701 int res1 = 0 ;
39702 int val2 ;
39703 int ecode2 = 0 ;
39704 int val3 ;
39705 int ecode3 = 0 ;
39706 bool val4 ;
39707 int ecode4 = 0 ;
39708 PyObject * obj0 = 0 ;
39709 PyObject * obj1 = 0 ;
39710 PyObject * obj2 = 0 ;
39711 PyObject * obj3 = 0 ;
39712 char * kwnames[] = {
39713 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39714 };
39715
39716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39718 if (!SWIG_IsOK(res1)) {
39719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39720 }
39721 arg1 = reinterpret_cast< wxWindow * >(argp1);
39722 ecode2 = SWIG_AsVal_int(obj1, &val2);
39723 if (!SWIG_IsOK(ecode2)) {
39724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39725 }
39726 arg2 = static_cast< int >(val2);
39727 ecode3 = SWIG_AsVal_int(obj2, &val3);
39728 if (!SWIG_IsOK(ecode3)) {
39729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39730 }
39731 arg3 = static_cast< int >(val3);
39732 if (obj3) {
39733 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39734 if (!SWIG_IsOK(ecode4)) {
39735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39736 }
39737 arg4 = static_cast< bool >(val4);
39738 }
39739 {
39740 PyThreadState* __tstate = wxPyBeginAllowThreads();
39741 (arg1)->SetScrollPos(arg2,arg3,arg4);
39742 wxPyEndAllowThreads(__tstate);
39743 if (PyErr_Occurred()) SWIG_fail;
39744 }
39745 resultobj = SWIG_Py_Void();
39746 return resultobj;
39747 fail:
39748 return NULL;
39749 }
39750
39751
39752 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39753 PyObject *resultobj = 0;
39754 wxWindow *arg1 = (wxWindow *) 0 ;
39755 int arg2 ;
39756 int result;
39757 void *argp1 = 0 ;
39758 int res1 = 0 ;
39759 int val2 ;
39760 int ecode2 = 0 ;
39761 PyObject * obj0 = 0 ;
39762 PyObject * obj1 = 0 ;
39763 char * kwnames[] = {
39764 (char *) "self",(char *) "orientation", NULL
39765 };
39766
39767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39769 if (!SWIG_IsOK(res1)) {
39770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39771 }
39772 arg1 = reinterpret_cast< wxWindow * >(argp1);
39773 ecode2 = SWIG_AsVal_int(obj1, &val2);
39774 if (!SWIG_IsOK(ecode2)) {
39775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39776 }
39777 arg2 = static_cast< int >(val2);
39778 {
39779 PyThreadState* __tstate = wxPyBeginAllowThreads();
39780 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 resultobj = SWIG_From_int(static_cast< int >(result));
39785 return resultobj;
39786 fail:
39787 return NULL;
39788 }
39789
39790
39791 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj = 0;
39793 wxWindow *arg1 = (wxWindow *) 0 ;
39794 int arg2 ;
39795 int result;
39796 void *argp1 = 0 ;
39797 int res1 = 0 ;
39798 int val2 ;
39799 int ecode2 = 0 ;
39800 PyObject * obj0 = 0 ;
39801 PyObject * obj1 = 0 ;
39802 char * kwnames[] = {
39803 (char *) "self",(char *) "orientation", NULL
39804 };
39805
39806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39808 if (!SWIG_IsOK(res1)) {
39809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39810 }
39811 arg1 = reinterpret_cast< wxWindow * >(argp1);
39812 ecode2 = SWIG_AsVal_int(obj1, &val2);
39813 if (!SWIG_IsOK(ecode2)) {
39814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39815 }
39816 arg2 = static_cast< int >(val2);
39817 {
39818 PyThreadState* __tstate = wxPyBeginAllowThreads();
39819 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39820 wxPyEndAllowThreads(__tstate);
39821 if (PyErr_Occurred()) SWIG_fail;
39822 }
39823 resultobj = SWIG_From_int(static_cast< int >(result));
39824 return resultobj;
39825 fail:
39826 return NULL;
39827 }
39828
39829
39830 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39831 PyObject *resultobj = 0;
39832 wxWindow *arg1 = (wxWindow *) 0 ;
39833 int arg2 ;
39834 int result;
39835 void *argp1 = 0 ;
39836 int res1 = 0 ;
39837 int val2 ;
39838 int ecode2 = 0 ;
39839 PyObject * obj0 = 0 ;
39840 PyObject * obj1 = 0 ;
39841 char * kwnames[] = {
39842 (char *) "self",(char *) "orientation", NULL
39843 };
39844
39845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39847 if (!SWIG_IsOK(res1)) {
39848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39849 }
39850 arg1 = reinterpret_cast< wxWindow * >(argp1);
39851 ecode2 = SWIG_AsVal_int(obj1, &val2);
39852 if (!SWIG_IsOK(ecode2)) {
39853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39854 }
39855 arg2 = static_cast< int >(val2);
39856 {
39857 PyThreadState* __tstate = wxPyBeginAllowThreads();
39858 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39859 wxPyEndAllowThreads(__tstate);
39860 if (PyErr_Occurred()) SWIG_fail;
39861 }
39862 resultobj = SWIG_From_int(static_cast< int >(result));
39863 return resultobj;
39864 fail:
39865 return NULL;
39866 }
39867
39868
39869 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39870 PyObject *resultobj = 0;
39871 wxWindow *arg1 = (wxWindow *) 0 ;
39872 int arg2 ;
39873 int arg3 ;
39874 wxRect *arg4 = (wxRect *) NULL ;
39875 void *argp1 = 0 ;
39876 int res1 = 0 ;
39877 int val2 ;
39878 int ecode2 = 0 ;
39879 int val3 ;
39880 int ecode3 = 0 ;
39881 void *argp4 = 0 ;
39882 int res4 = 0 ;
39883 PyObject * obj0 = 0 ;
39884 PyObject * obj1 = 0 ;
39885 PyObject * obj2 = 0 ;
39886 PyObject * obj3 = 0 ;
39887 char * kwnames[] = {
39888 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39889 };
39890
39891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39893 if (!SWIG_IsOK(res1)) {
39894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39895 }
39896 arg1 = reinterpret_cast< wxWindow * >(argp1);
39897 ecode2 = SWIG_AsVal_int(obj1, &val2);
39898 if (!SWIG_IsOK(ecode2)) {
39899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39900 }
39901 arg2 = static_cast< int >(val2);
39902 ecode3 = SWIG_AsVal_int(obj2, &val3);
39903 if (!SWIG_IsOK(ecode3)) {
39904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39905 }
39906 arg3 = static_cast< int >(val3);
39907 if (obj3) {
39908 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39909 if (!SWIG_IsOK(res4)) {
39910 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39911 }
39912 arg4 = reinterpret_cast< wxRect * >(argp4);
39913 }
39914 {
39915 PyThreadState* __tstate = wxPyBeginAllowThreads();
39916 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39917 wxPyEndAllowThreads(__tstate);
39918 if (PyErr_Occurred()) SWIG_fail;
39919 }
39920 resultobj = SWIG_Py_Void();
39921 return resultobj;
39922 fail:
39923 return NULL;
39924 }
39925
39926
39927 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39928 PyObject *resultobj = 0;
39929 wxWindow *arg1 = (wxWindow *) 0 ;
39930 int arg2 ;
39931 bool result;
39932 void *argp1 = 0 ;
39933 int res1 = 0 ;
39934 int val2 ;
39935 int ecode2 = 0 ;
39936 PyObject * obj0 = 0 ;
39937 PyObject * obj1 = 0 ;
39938 char * kwnames[] = {
39939 (char *) "self",(char *) "lines", NULL
39940 };
39941
39942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39944 if (!SWIG_IsOK(res1)) {
39945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39946 }
39947 arg1 = reinterpret_cast< wxWindow * >(argp1);
39948 ecode2 = SWIG_AsVal_int(obj1, &val2);
39949 if (!SWIG_IsOK(ecode2)) {
39950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39951 }
39952 arg2 = static_cast< int >(val2);
39953 {
39954 PyThreadState* __tstate = wxPyBeginAllowThreads();
39955 result = (bool)(arg1)->ScrollLines(arg2);
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 {
39960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39961 }
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39969 PyObject *resultobj = 0;
39970 wxWindow *arg1 = (wxWindow *) 0 ;
39971 int arg2 ;
39972 bool result;
39973 void *argp1 = 0 ;
39974 int res1 = 0 ;
39975 int val2 ;
39976 int ecode2 = 0 ;
39977 PyObject * obj0 = 0 ;
39978 PyObject * obj1 = 0 ;
39979 char * kwnames[] = {
39980 (char *) "self",(char *) "pages", NULL
39981 };
39982
39983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
39984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39985 if (!SWIG_IsOK(res1)) {
39986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
39987 }
39988 arg1 = reinterpret_cast< wxWindow * >(argp1);
39989 ecode2 = SWIG_AsVal_int(obj1, &val2);
39990 if (!SWIG_IsOK(ecode2)) {
39991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
39992 }
39993 arg2 = static_cast< int >(val2);
39994 {
39995 PyThreadState* __tstate = wxPyBeginAllowThreads();
39996 result = (bool)(arg1)->ScrollPages(arg2);
39997 wxPyEndAllowThreads(__tstate);
39998 if (PyErr_Occurred()) SWIG_fail;
39999 }
40000 {
40001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40002 }
40003 return resultobj;
40004 fail:
40005 return NULL;
40006 }
40007
40008
40009 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40010 PyObject *resultobj = 0;
40011 wxWindow *arg1 = (wxWindow *) 0 ;
40012 bool result;
40013 void *argp1 = 0 ;
40014 int res1 = 0 ;
40015 PyObject *swig_obj[1] ;
40016
40017 if (!args) SWIG_fail;
40018 swig_obj[0] = args;
40019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40020 if (!SWIG_IsOK(res1)) {
40021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40022 }
40023 arg1 = reinterpret_cast< wxWindow * >(argp1);
40024 {
40025 PyThreadState* __tstate = wxPyBeginAllowThreads();
40026 result = (bool)(arg1)->LineUp();
40027 wxPyEndAllowThreads(__tstate);
40028 if (PyErr_Occurred()) SWIG_fail;
40029 }
40030 {
40031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40032 }
40033 return resultobj;
40034 fail:
40035 return NULL;
40036 }
40037
40038
40039 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40040 PyObject *resultobj = 0;
40041 wxWindow *arg1 = (wxWindow *) 0 ;
40042 bool result;
40043 void *argp1 = 0 ;
40044 int res1 = 0 ;
40045 PyObject *swig_obj[1] ;
40046
40047 if (!args) SWIG_fail;
40048 swig_obj[0] = args;
40049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40050 if (!SWIG_IsOK(res1)) {
40051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40052 }
40053 arg1 = reinterpret_cast< wxWindow * >(argp1);
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 result = (bool)(arg1)->LineDown();
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 {
40061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40062 }
40063 return resultobj;
40064 fail:
40065 return NULL;
40066 }
40067
40068
40069 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40070 PyObject *resultobj = 0;
40071 wxWindow *arg1 = (wxWindow *) 0 ;
40072 bool result;
40073 void *argp1 = 0 ;
40074 int res1 = 0 ;
40075 PyObject *swig_obj[1] ;
40076
40077 if (!args) SWIG_fail;
40078 swig_obj[0] = args;
40079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40080 if (!SWIG_IsOK(res1)) {
40081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40082 }
40083 arg1 = reinterpret_cast< wxWindow * >(argp1);
40084 {
40085 PyThreadState* __tstate = wxPyBeginAllowThreads();
40086 result = (bool)(arg1)->PageUp();
40087 wxPyEndAllowThreads(__tstate);
40088 if (PyErr_Occurred()) SWIG_fail;
40089 }
40090 {
40091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40092 }
40093 return resultobj;
40094 fail:
40095 return NULL;
40096 }
40097
40098
40099 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40100 PyObject *resultobj = 0;
40101 wxWindow *arg1 = (wxWindow *) 0 ;
40102 bool result;
40103 void *argp1 = 0 ;
40104 int res1 = 0 ;
40105 PyObject *swig_obj[1] ;
40106
40107 if (!args) SWIG_fail;
40108 swig_obj[0] = args;
40109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40110 if (!SWIG_IsOK(res1)) {
40111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40112 }
40113 arg1 = reinterpret_cast< wxWindow * >(argp1);
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 result = (bool)(arg1)->PageDown();
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 {
40121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40122 }
40123 return resultobj;
40124 fail:
40125 return NULL;
40126 }
40127
40128
40129 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40130 PyObject *resultobj = 0;
40131 wxWindow *arg1 = (wxWindow *) 0 ;
40132 wxString *arg2 = 0 ;
40133 void *argp1 = 0 ;
40134 int res1 = 0 ;
40135 bool temp2 = false ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "text", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40146 }
40147 arg1 = reinterpret_cast< wxWindow * >(argp1);
40148 {
40149 arg2 = wxString_in_helper(obj1);
40150 if (arg2 == NULL) SWIG_fail;
40151 temp2 = true;
40152 }
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 (arg1)->SetHelpText((wxString const &)*arg2);
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 resultobj = SWIG_Py_Void();
40160 {
40161 if (temp2)
40162 delete arg2;
40163 }
40164 return resultobj;
40165 fail:
40166 {
40167 if (temp2)
40168 delete arg2;
40169 }
40170 return NULL;
40171 }
40172
40173
40174 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40175 PyObject *resultobj = 0;
40176 wxWindow *arg1 = (wxWindow *) 0 ;
40177 wxString *arg2 = 0 ;
40178 void *argp1 = 0 ;
40179 int res1 = 0 ;
40180 bool temp2 = false ;
40181 PyObject * obj0 = 0 ;
40182 PyObject * obj1 = 0 ;
40183 char * kwnames[] = {
40184 (char *) "self",(char *) "text", NULL
40185 };
40186
40187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40191 }
40192 arg1 = reinterpret_cast< wxWindow * >(argp1);
40193 {
40194 arg2 = wxString_in_helper(obj1);
40195 if (arg2 == NULL) SWIG_fail;
40196 temp2 = true;
40197 }
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40201 wxPyEndAllowThreads(__tstate);
40202 if (PyErr_Occurred()) SWIG_fail;
40203 }
40204 resultobj = SWIG_Py_Void();
40205 {
40206 if (temp2)
40207 delete arg2;
40208 }
40209 return resultobj;
40210 fail:
40211 {
40212 if (temp2)
40213 delete arg2;
40214 }
40215 return NULL;
40216 }
40217
40218
40219 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40220 PyObject *resultobj = 0;
40221 wxWindow *arg1 = (wxWindow *) 0 ;
40222 wxPoint *arg2 = 0 ;
40223 wxHelpEvent::Origin arg3 ;
40224 wxString result;
40225 void *argp1 = 0 ;
40226 int res1 = 0 ;
40227 wxPoint temp2 ;
40228 void *argp3 ;
40229 int res3 = 0 ;
40230 PyObject * obj0 = 0 ;
40231 PyObject * obj1 = 0 ;
40232 PyObject * obj2 = 0 ;
40233 char * kwnames[] = {
40234 (char *) "self",(char *) "pt",(char *) "origin", NULL
40235 };
40236
40237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40239 if (!SWIG_IsOK(res1)) {
40240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40241 }
40242 arg1 = reinterpret_cast< wxWindow * >(argp1);
40243 {
40244 arg2 = &temp2;
40245 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40246 }
40247 {
40248 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40249 if (!SWIG_IsOK(res3)) {
40250 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40251 }
40252 if (!argp3) {
40253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40254 } else {
40255 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40256 arg3 = *temp;
40257 if (SWIG_IsNewObj(res3)) delete temp;
40258 }
40259 }
40260 {
40261 PyThreadState* __tstate = wxPyBeginAllowThreads();
40262 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 {
40267 #if wxUSE_UNICODE
40268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40269 #else
40270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40271 #endif
40272 }
40273 return resultobj;
40274 fail:
40275 return NULL;
40276 }
40277
40278
40279 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40280 PyObject *resultobj = 0;
40281 wxWindow *arg1 = (wxWindow *) 0 ;
40282 wxString result;
40283 void *argp1 = 0 ;
40284 int res1 = 0 ;
40285 PyObject *swig_obj[1] ;
40286
40287 if (!args) SWIG_fail;
40288 swig_obj[0] = args;
40289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40290 if (!SWIG_IsOK(res1)) {
40291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40292 }
40293 arg1 = reinterpret_cast< wxWindow * >(argp1);
40294 {
40295 PyThreadState* __tstate = wxPyBeginAllowThreads();
40296 result = ((wxWindow const *)arg1)->GetHelpText();
40297 wxPyEndAllowThreads(__tstate);
40298 if (PyErr_Occurred()) SWIG_fail;
40299 }
40300 {
40301 #if wxUSE_UNICODE
40302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40303 #else
40304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40305 #endif
40306 }
40307 return resultobj;
40308 fail:
40309 return NULL;
40310 }
40311
40312
40313 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40314 PyObject *resultobj = 0;
40315 wxWindow *arg1 = (wxWindow *) 0 ;
40316 wxString *arg2 = 0 ;
40317 void *argp1 = 0 ;
40318 int res1 = 0 ;
40319 bool temp2 = false ;
40320 PyObject * obj0 = 0 ;
40321 PyObject * obj1 = 0 ;
40322 char * kwnames[] = {
40323 (char *) "self",(char *) "tip", NULL
40324 };
40325
40326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40328 if (!SWIG_IsOK(res1)) {
40329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40330 }
40331 arg1 = reinterpret_cast< wxWindow * >(argp1);
40332 {
40333 arg2 = wxString_in_helper(obj1);
40334 if (arg2 == NULL) SWIG_fail;
40335 temp2 = true;
40336 }
40337 {
40338 PyThreadState* __tstate = wxPyBeginAllowThreads();
40339 (arg1)->SetToolTip((wxString const &)*arg2);
40340 wxPyEndAllowThreads(__tstate);
40341 if (PyErr_Occurred()) SWIG_fail;
40342 }
40343 resultobj = SWIG_Py_Void();
40344 {
40345 if (temp2)
40346 delete arg2;
40347 }
40348 return resultobj;
40349 fail:
40350 {
40351 if (temp2)
40352 delete arg2;
40353 }
40354 return NULL;
40355 }
40356
40357
40358 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40359 PyObject *resultobj = 0;
40360 wxWindow *arg1 = (wxWindow *) 0 ;
40361 wxToolTip *arg2 = (wxToolTip *) 0 ;
40362 void *argp1 = 0 ;
40363 int res1 = 0 ;
40364 int res2 = 0 ;
40365 PyObject * obj0 = 0 ;
40366 PyObject * obj1 = 0 ;
40367 char * kwnames[] = {
40368 (char *) "self",(char *) "tip", NULL
40369 };
40370
40371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40373 if (!SWIG_IsOK(res1)) {
40374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40375 }
40376 arg1 = reinterpret_cast< wxWindow * >(argp1);
40377 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40378 if (!SWIG_IsOK(res2)) {
40379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40380 }
40381 {
40382 PyThreadState* __tstate = wxPyBeginAllowThreads();
40383 (arg1)->SetToolTip(arg2);
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 resultobj = SWIG_Py_Void();
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40395 PyObject *resultobj = 0;
40396 wxWindow *arg1 = (wxWindow *) 0 ;
40397 wxToolTip *result = 0 ;
40398 void *argp1 = 0 ;
40399 int res1 = 0 ;
40400 PyObject *swig_obj[1] ;
40401
40402 if (!args) SWIG_fail;
40403 swig_obj[0] = args;
40404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40405 if (!SWIG_IsOK(res1)) {
40406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40407 }
40408 arg1 = reinterpret_cast< wxWindow * >(argp1);
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 {
40416 resultobj = wxPyMake_wxObject(result, (bool)0);
40417 }
40418 return resultobj;
40419 fail:
40420 return NULL;
40421 }
40422
40423
40424 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40425 PyObject *resultobj = 0;
40426 wxWindow *arg1 = (wxWindow *) 0 ;
40427 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40428 void *argp1 = 0 ;
40429 int res1 = 0 ;
40430 int res2 = 0 ;
40431 PyObject * obj0 = 0 ;
40432 PyObject * obj1 = 0 ;
40433 char * kwnames[] = {
40434 (char *) "self",(char *) "dropTarget", NULL
40435 };
40436
40437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40439 if (!SWIG_IsOK(res1)) {
40440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40441 }
40442 arg1 = reinterpret_cast< wxWindow * >(argp1);
40443 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40444 if (!SWIG_IsOK(res2)) {
40445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40446 }
40447 {
40448 PyThreadState* __tstate = wxPyBeginAllowThreads();
40449 (arg1)->SetDropTarget(arg2);
40450 wxPyEndAllowThreads(__tstate);
40451 if (PyErr_Occurred()) SWIG_fail;
40452 }
40453 resultobj = SWIG_Py_Void();
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40461 PyObject *resultobj = 0;
40462 wxWindow *arg1 = (wxWindow *) 0 ;
40463 wxPyDropTarget *result = 0 ;
40464 void *argp1 = 0 ;
40465 int res1 = 0 ;
40466 PyObject *swig_obj[1] ;
40467
40468 if (!args) SWIG_fail;
40469 swig_obj[0] = args;
40470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40471 if (!SWIG_IsOK(res1)) {
40472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40473 }
40474 arg1 = reinterpret_cast< wxWindow * >(argp1);
40475 {
40476 PyThreadState* __tstate = wxPyBeginAllowThreads();
40477 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40478 wxPyEndAllowThreads(__tstate);
40479 if (PyErr_Occurred()) SWIG_fail;
40480 }
40481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40482 return resultobj;
40483 fail:
40484 return NULL;
40485 }
40486
40487
40488 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40489 PyObject *resultobj = 0;
40490 wxWindow *arg1 = (wxWindow *) 0 ;
40491 bool arg2 ;
40492 void *argp1 = 0 ;
40493 int res1 = 0 ;
40494 bool val2 ;
40495 int ecode2 = 0 ;
40496 PyObject * obj0 = 0 ;
40497 PyObject * obj1 = 0 ;
40498 char * kwnames[] = {
40499 (char *) "self",(char *) "accept", NULL
40500 };
40501
40502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40504 if (!SWIG_IsOK(res1)) {
40505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40506 }
40507 arg1 = reinterpret_cast< wxWindow * >(argp1);
40508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40509 if (!SWIG_IsOK(ecode2)) {
40510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40511 }
40512 arg2 = static_cast< bool >(val2);
40513 {
40514 PyThreadState* __tstate = wxPyBeginAllowThreads();
40515 wxWindow_DragAcceptFiles(arg1,arg2);
40516 wxPyEndAllowThreads(__tstate);
40517 if (PyErr_Occurred()) SWIG_fail;
40518 }
40519 resultobj = SWIG_Py_Void();
40520 return resultobj;
40521 fail:
40522 return NULL;
40523 }
40524
40525
40526 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40527 PyObject *resultobj = 0;
40528 wxWindow *arg1 = (wxWindow *) 0 ;
40529 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40530 void *argp1 = 0 ;
40531 int res1 = 0 ;
40532 int res2 = 0 ;
40533 PyObject * obj0 = 0 ;
40534 PyObject * obj1 = 0 ;
40535 char * kwnames[] = {
40536 (char *) "self",(char *) "constraints", NULL
40537 };
40538
40539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40541 if (!SWIG_IsOK(res1)) {
40542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40543 }
40544 arg1 = reinterpret_cast< wxWindow * >(argp1);
40545 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40546 if (!SWIG_IsOK(res2)) {
40547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40548 }
40549 {
40550 PyThreadState* __tstate = wxPyBeginAllowThreads();
40551 (arg1)->SetConstraints(arg2);
40552 wxPyEndAllowThreads(__tstate);
40553 if (PyErr_Occurred()) SWIG_fail;
40554 }
40555 resultobj = SWIG_Py_Void();
40556 return resultobj;
40557 fail:
40558 return NULL;
40559 }
40560
40561
40562 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40563 PyObject *resultobj = 0;
40564 wxWindow *arg1 = (wxWindow *) 0 ;
40565 wxLayoutConstraints *result = 0 ;
40566 void *argp1 = 0 ;
40567 int res1 = 0 ;
40568 PyObject *swig_obj[1] ;
40569
40570 if (!args) SWIG_fail;
40571 swig_obj[0] = args;
40572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40573 if (!SWIG_IsOK(res1)) {
40574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40575 }
40576 arg1 = reinterpret_cast< wxWindow * >(argp1);
40577 {
40578 PyThreadState* __tstate = wxPyBeginAllowThreads();
40579 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40580 wxPyEndAllowThreads(__tstate);
40581 if (PyErr_Occurred()) SWIG_fail;
40582 }
40583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40584 return resultobj;
40585 fail:
40586 return NULL;
40587 }
40588
40589
40590 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40591 PyObject *resultobj = 0;
40592 wxWindow *arg1 = (wxWindow *) 0 ;
40593 bool arg2 ;
40594 void *argp1 = 0 ;
40595 int res1 = 0 ;
40596 bool val2 ;
40597 int ecode2 = 0 ;
40598 PyObject * obj0 = 0 ;
40599 PyObject * obj1 = 0 ;
40600 char * kwnames[] = {
40601 (char *) "self",(char *) "autoLayout", NULL
40602 };
40603
40604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40606 if (!SWIG_IsOK(res1)) {
40607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40608 }
40609 arg1 = reinterpret_cast< wxWindow * >(argp1);
40610 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40611 if (!SWIG_IsOK(ecode2)) {
40612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40613 }
40614 arg2 = static_cast< bool >(val2);
40615 {
40616 PyThreadState* __tstate = wxPyBeginAllowThreads();
40617 (arg1)->SetAutoLayout(arg2);
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 resultobj = SWIG_Py_Void();
40622 return resultobj;
40623 fail:
40624 return NULL;
40625 }
40626
40627
40628 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40629 PyObject *resultobj = 0;
40630 wxWindow *arg1 = (wxWindow *) 0 ;
40631 bool result;
40632 void *argp1 = 0 ;
40633 int res1 = 0 ;
40634 PyObject *swig_obj[1] ;
40635
40636 if (!args) SWIG_fail;
40637 swig_obj[0] = args;
40638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40639 if (!SWIG_IsOK(res1)) {
40640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40641 }
40642 arg1 = reinterpret_cast< wxWindow * >(argp1);
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40646 wxPyEndAllowThreads(__tstate);
40647 if (PyErr_Occurred()) SWIG_fail;
40648 }
40649 {
40650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40651 }
40652 return resultobj;
40653 fail:
40654 return NULL;
40655 }
40656
40657
40658 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40659 PyObject *resultobj = 0;
40660 wxWindow *arg1 = (wxWindow *) 0 ;
40661 bool result;
40662 void *argp1 = 0 ;
40663 int res1 = 0 ;
40664 PyObject *swig_obj[1] ;
40665
40666 if (!args) SWIG_fail;
40667 swig_obj[0] = args;
40668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40669 if (!SWIG_IsOK(res1)) {
40670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40671 }
40672 arg1 = reinterpret_cast< wxWindow * >(argp1);
40673 {
40674 PyThreadState* __tstate = wxPyBeginAllowThreads();
40675 result = (bool)(arg1)->Layout();
40676 wxPyEndAllowThreads(__tstate);
40677 if (PyErr_Occurred()) SWIG_fail;
40678 }
40679 {
40680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40681 }
40682 return resultobj;
40683 fail:
40684 return NULL;
40685 }
40686
40687
40688 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40689 PyObject *resultobj = 0;
40690 wxWindow *arg1 = (wxWindow *) 0 ;
40691 wxSizer *arg2 = (wxSizer *) 0 ;
40692 bool arg3 = (bool) true ;
40693 void *argp1 = 0 ;
40694 int res1 = 0 ;
40695 int res2 = 0 ;
40696 bool val3 ;
40697 int ecode3 = 0 ;
40698 PyObject * obj0 = 0 ;
40699 PyObject * obj1 = 0 ;
40700 PyObject * obj2 = 0 ;
40701 char * kwnames[] = {
40702 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40703 };
40704
40705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40707 if (!SWIG_IsOK(res1)) {
40708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40709 }
40710 arg1 = reinterpret_cast< wxWindow * >(argp1);
40711 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40712 if (!SWIG_IsOK(res2)) {
40713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40714 }
40715 if (obj2) {
40716 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40717 if (!SWIG_IsOK(ecode3)) {
40718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40719 }
40720 arg3 = static_cast< bool >(val3);
40721 }
40722 {
40723 PyThreadState* __tstate = wxPyBeginAllowThreads();
40724 (arg1)->SetSizer(arg2,arg3);
40725 wxPyEndAllowThreads(__tstate);
40726 if (PyErr_Occurred()) SWIG_fail;
40727 }
40728 resultobj = SWIG_Py_Void();
40729 return resultobj;
40730 fail:
40731 return NULL;
40732 }
40733
40734
40735 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40736 PyObject *resultobj = 0;
40737 wxWindow *arg1 = (wxWindow *) 0 ;
40738 wxSizer *arg2 = (wxSizer *) 0 ;
40739 bool arg3 = (bool) true ;
40740 void *argp1 = 0 ;
40741 int res1 = 0 ;
40742 int res2 = 0 ;
40743 bool val3 ;
40744 int ecode3 = 0 ;
40745 PyObject * obj0 = 0 ;
40746 PyObject * obj1 = 0 ;
40747 PyObject * obj2 = 0 ;
40748 char * kwnames[] = {
40749 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40750 };
40751
40752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40754 if (!SWIG_IsOK(res1)) {
40755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40756 }
40757 arg1 = reinterpret_cast< wxWindow * >(argp1);
40758 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40759 if (!SWIG_IsOK(res2)) {
40760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40761 }
40762 if (obj2) {
40763 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40764 if (!SWIG_IsOK(ecode3)) {
40765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40766 }
40767 arg3 = static_cast< bool >(val3);
40768 }
40769 {
40770 PyThreadState* __tstate = wxPyBeginAllowThreads();
40771 (arg1)->SetSizerAndFit(arg2,arg3);
40772 wxPyEndAllowThreads(__tstate);
40773 if (PyErr_Occurred()) SWIG_fail;
40774 }
40775 resultobj = SWIG_Py_Void();
40776 return resultobj;
40777 fail:
40778 return NULL;
40779 }
40780
40781
40782 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40783 PyObject *resultobj = 0;
40784 wxWindow *arg1 = (wxWindow *) 0 ;
40785 wxSizer *result = 0 ;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 PyObject *swig_obj[1] ;
40789
40790 if (!args) SWIG_fail;
40791 swig_obj[0] = args;
40792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40793 if (!SWIG_IsOK(res1)) {
40794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40795 }
40796 arg1 = reinterpret_cast< wxWindow * >(argp1);
40797 {
40798 PyThreadState* __tstate = wxPyBeginAllowThreads();
40799 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 {
40804 resultobj = wxPyMake_wxObject(result, (bool)0);
40805 }
40806 return resultobj;
40807 fail:
40808 return NULL;
40809 }
40810
40811
40812 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40813 PyObject *resultobj = 0;
40814 wxWindow *arg1 = (wxWindow *) 0 ;
40815 wxSizer *arg2 = (wxSizer *) 0 ;
40816 void *argp1 = 0 ;
40817 int res1 = 0 ;
40818 void *argp2 = 0 ;
40819 int res2 = 0 ;
40820 PyObject * obj0 = 0 ;
40821 PyObject * obj1 = 0 ;
40822 char * kwnames[] = {
40823 (char *) "self",(char *) "sizer", NULL
40824 };
40825
40826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40828 if (!SWIG_IsOK(res1)) {
40829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40830 }
40831 arg1 = reinterpret_cast< wxWindow * >(argp1);
40832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40833 if (!SWIG_IsOK(res2)) {
40834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40835 }
40836 arg2 = reinterpret_cast< wxSizer * >(argp2);
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->SetContainingSizer(arg2);
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 resultobj = SWIG_Py_Void();
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40851 PyObject *resultobj = 0;
40852 wxWindow *arg1 = (wxWindow *) 0 ;
40853 wxSizer *result = 0 ;
40854 void *argp1 = 0 ;
40855 int res1 = 0 ;
40856 PyObject *swig_obj[1] ;
40857
40858 if (!args) SWIG_fail;
40859 swig_obj[0] = args;
40860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40861 if (!SWIG_IsOK(res1)) {
40862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40863 }
40864 arg1 = reinterpret_cast< wxWindow * >(argp1);
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 {
40872 resultobj = wxPyMake_wxObject(result, (bool)0);
40873 }
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40881 PyObject *resultobj = 0;
40882 wxWindow *arg1 = (wxWindow *) 0 ;
40883 void *argp1 = 0 ;
40884 int res1 = 0 ;
40885 PyObject *swig_obj[1] ;
40886
40887 if (!args) SWIG_fail;
40888 swig_obj[0] = args;
40889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40890 if (!SWIG_IsOK(res1)) {
40891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40892 }
40893 arg1 = reinterpret_cast< wxWindow * >(argp1);
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 (arg1)->InheritAttributes();
40897 wxPyEndAllowThreads(__tstate);
40898 if (PyErr_Occurred()) SWIG_fail;
40899 }
40900 resultobj = SWIG_Py_Void();
40901 return resultobj;
40902 fail:
40903 return NULL;
40904 }
40905
40906
40907 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40908 PyObject *resultobj = 0;
40909 wxWindow *arg1 = (wxWindow *) 0 ;
40910 bool result;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 PyObject *swig_obj[1] ;
40914
40915 if (!args) SWIG_fail;
40916 swig_obj[0] = args;
40917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40918 if (!SWIG_IsOK(res1)) {
40919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40920 }
40921 arg1 = reinterpret_cast< wxWindow * >(argp1);
40922 {
40923 PyThreadState* __tstate = wxPyBeginAllowThreads();
40924 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40925 wxPyEndAllowThreads(__tstate);
40926 if (PyErr_Occurred()) SWIG_fail;
40927 }
40928 {
40929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40930 }
40931 return resultobj;
40932 fail:
40933 return NULL;
40934 }
40935
40936
40937 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40938 PyObject *resultobj = 0;
40939 wxWindow *arg1 = (wxWindow *) 0 ;
40940 bool result;
40941 void *argp1 = 0 ;
40942 int res1 = 0 ;
40943 PyObject *swig_obj[1] ;
40944
40945 if (!args) SWIG_fail;
40946 swig_obj[0] = args;
40947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40948 if (!SWIG_IsOK(res1)) {
40949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40950 }
40951 arg1 = reinterpret_cast< wxWindow * >(argp1);
40952 {
40953 PyThreadState* __tstate = wxPyBeginAllowThreads();
40954 result = (bool)(arg1)->CanSetTransparent();
40955 wxPyEndAllowThreads(__tstate);
40956 if (PyErr_Occurred()) SWIG_fail;
40957 }
40958 {
40959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40960 }
40961 return resultobj;
40962 fail:
40963 return NULL;
40964 }
40965
40966
40967 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40968 PyObject *resultobj = 0;
40969 wxWindow *arg1 = (wxWindow *) 0 ;
40970 byte arg2 ;
40971 bool result;
40972 void *argp1 = 0 ;
40973 int res1 = 0 ;
40974 unsigned char val2 ;
40975 int ecode2 = 0 ;
40976 PyObject * obj0 = 0 ;
40977 PyObject * obj1 = 0 ;
40978 char * kwnames[] = {
40979 (char *) "self",(char *) "alpha", NULL
40980 };
40981
40982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
40983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40984 if (!SWIG_IsOK(res1)) {
40985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40986 }
40987 arg1 = reinterpret_cast< wxWindow * >(argp1);
40988 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
40989 if (!SWIG_IsOK(ecode2)) {
40990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
40991 }
40992 arg2 = static_cast< byte >(val2);
40993 {
40994 PyThreadState* __tstate = wxPyBeginAllowThreads();
40995 result = (bool)(arg1)->SetTransparent(arg2);
40996 wxPyEndAllowThreads(__tstate);
40997 if (PyErr_Occurred()) SWIG_fail;
40998 }
40999 {
41000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41001 }
41002 return resultobj;
41003 fail:
41004 return NULL;
41005 }
41006
41007
41008 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41009 PyObject *obj;
41010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41011 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41012 return SWIG_Py_Void();
41013 }
41014
41015 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41016 return SWIG_Python_InitShadowInstance(args);
41017 }
41018
41019 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 long arg1 ;
41022 wxWindow *arg2 = (wxWindow *) NULL ;
41023 wxWindow *result = 0 ;
41024 long val1 ;
41025 int ecode1 = 0 ;
41026 void *argp2 = 0 ;
41027 int res2 = 0 ;
41028 PyObject * obj0 = 0 ;
41029 PyObject * obj1 = 0 ;
41030 char * kwnames[] = {
41031 (char *) "id",(char *) "parent", NULL
41032 };
41033
41034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41035 ecode1 = SWIG_AsVal_long(obj0, &val1);
41036 if (!SWIG_IsOK(ecode1)) {
41037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41038 }
41039 arg1 = static_cast< long >(val1);
41040 if (obj1) {
41041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41042 if (!SWIG_IsOK(res2)) {
41043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41044 }
41045 arg2 = reinterpret_cast< wxWindow * >(argp2);
41046 }
41047 {
41048 if (!wxPyCheckForApp()) SWIG_fail;
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 {
41055 resultobj = wxPyMake_wxObject(result, 0);
41056 }
41057 return resultobj;
41058 fail:
41059 return NULL;
41060 }
41061
41062
41063 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj = 0;
41065 wxString *arg1 = 0 ;
41066 wxWindow *arg2 = (wxWindow *) NULL ;
41067 wxWindow *result = 0 ;
41068 bool temp1 = false ;
41069 void *argp2 = 0 ;
41070 int res2 = 0 ;
41071 PyObject * obj0 = 0 ;
41072 PyObject * obj1 = 0 ;
41073 char * kwnames[] = {
41074 (char *) "name",(char *) "parent", NULL
41075 };
41076
41077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41078 {
41079 arg1 = wxString_in_helper(obj0);
41080 if (arg1 == NULL) SWIG_fail;
41081 temp1 = true;
41082 }
41083 if (obj1) {
41084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41085 if (!SWIG_IsOK(res2)) {
41086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41087 }
41088 arg2 = reinterpret_cast< wxWindow * >(argp2);
41089 }
41090 {
41091 if (!wxPyCheckForApp()) SWIG_fail;
41092 PyThreadState* __tstate = wxPyBeginAllowThreads();
41093 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41094 wxPyEndAllowThreads(__tstate);
41095 if (PyErr_Occurred()) SWIG_fail;
41096 }
41097 {
41098 resultobj = wxPyMake_wxObject(result, 0);
41099 }
41100 {
41101 if (temp1)
41102 delete arg1;
41103 }
41104 return resultobj;
41105 fail:
41106 {
41107 if (temp1)
41108 delete arg1;
41109 }
41110 return NULL;
41111 }
41112
41113
41114 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41115 PyObject *resultobj = 0;
41116 wxString *arg1 = 0 ;
41117 wxWindow *arg2 = (wxWindow *) NULL ;
41118 wxWindow *result = 0 ;
41119 bool temp1 = false ;
41120 void *argp2 = 0 ;
41121 int res2 = 0 ;
41122 PyObject * obj0 = 0 ;
41123 PyObject * obj1 = 0 ;
41124 char * kwnames[] = {
41125 (char *) "label",(char *) "parent", NULL
41126 };
41127
41128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41129 {
41130 arg1 = wxString_in_helper(obj0);
41131 if (arg1 == NULL) SWIG_fail;
41132 temp1 = true;
41133 }
41134 if (obj1) {
41135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41136 if (!SWIG_IsOK(res2)) {
41137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41138 }
41139 arg2 = reinterpret_cast< wxWindow * >(argp2);
41140 }
41141 {
41142 if (!wxPyCheckForApp()) SWIG_fail;
41143 PyThreadState* __tstate = wxPyBeginAllowThreads();
41144 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41145 wxPyEndAllowThreads(__tstate);
41146 if (PyErr_Occurred()) SWIG_fail;
41147 }
41148 {
41149 resultobj = wxPyMake_wxObject(result, 0);
41150 }
41151 {
41152 if (temp1)
41153 delete arg1;
41154 }
41155 return resultobj;
41156 fail:
41157 {
41158 if (temp1)
41159 delete arg1;
41160 }
41161 return NULL;
41162 }
41163
41164
41165 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41166 PyObject *resultobj = 0;
41167 wxWindow *arg1 = (wxWindow *) 0 ;
41168 unsigned long arg2 ;
41169 wxWindow *result = 0 ;
41170 void *argp1 = 0 ;
41171 int res1 = 0 ;
41172 unsigned long val2 ;
41173 int ecode2 = 0 ;
41174 PyObject * obj0 = 0 ;
41175 PyObject * obj1 = 0 ;
41176 char * kwnames[] = {
41177 (char *) "parent",(char *) "_hWnd", NULL
41178 };
41179
41180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41182 if (!SWIG_IsOK(res1)) {
41183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41184 }
41185 arg1 = reinterpret_cast< wxWindow * >(argp1);
41186 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41187 if (!SWIG_IsOK(ecode2)) {
41188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41189 }
41190 arg2 = static_cast< unsigned long >(val2);
41191 {
41192 PyThreadState* __tstate = wxPyBeginAllowThreads();
41193 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41194 wxPyEndAllowThreads(__tstate);
41195 if (PyErr_Occurred()) SWIG_fail;
41196 }
41197 {
41198 resultobj = wxPyMake_wxObject(result, 0);
41199 }
41200 return resultobj;
41201 fail:
41202 return NULL;
41203 }
41204
41205
41206 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41207 PyObject *resultobj = 0;
41208 PyObject *result = 0 ;
41209
41210 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41211 {
41212 PyThreadState* __tstate = wxPyBeginAllowThreads();
41213 result = (PyObject *)GetTopLevelWindows();
41214 wxPyEndAllowThreads(__tstate);
41215 if (PyErr_Occurred()) SWIG_fail;
41216 }
41217 resultobj = result;
41218 return resultobj;
41219 fail:
41220 return NULL;
41221 }
41222
41223
41224 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41225 PyObject *resultobj = 0;
41226 wxValidator *result = 0 ;
41227
41228 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41229 {
41230 PyThreadState* __tstate = wxPyBeginAllowThreads();
41231 result = (wxValidator *)new wxValidator();
41232 wxPyEndAllowThreads(__tstate);
41233 if (PyErr_Occurred()) SWIG_fail;
41234 }
41235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41236 return resultobj;
41237 fail:
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41243 PyObject *resultobj = 0;
41244 wxValidator *arg1 = (wxValidator *) 0 ;
41245 wxValidator *result = 0 ;
41246 void *argp1 = 0 ;
41247 int res1 = 0 ;
41248 PyObject *swig_obj[1] ;
41249
41250 if (!args) SWIG_fail;
41251 swig_obj[0] = args;
41252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41253 if (!SWIG_IsOK(res1)) {
41254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41255 }
41256 arg1 = reinterpret_cast< wxValidator * >(argp1);
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 result = (wxValidator *)(arg1)->Clone();
41260 wxPyEndAllowThreads(__tstate);
41261 if (PyErr_Occurred()) SWIG_fail;
41262 }
41263 {
41264 resultobj = wxPyMake_wxObject(result, 0);
41265 }
41266 return resultobj;
41267 fail:
41268 return NULL;
41269 }
41270
41271
41272 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41273 PyObject *resultobj = 0;
41274 wxValidator *arg1 = (wxValidator *) 0 ;
41275 wxWindow *arg2 = (wxWindow *) 0 ;
41276 bool result;
41277 void *argp1 = 0 ;
41278 int res1 = 0 ;
41279 void *argp2 = 0 ;
41280 int res2 = 0 ;
41281 PyObject * obj0 = 0 ;
41282 PyObject * obj1 = 0 ;
41283 char * kwnames[] = {
41284 (char *) "self",(char *) "parent", NULL
41285 };
41286
41287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41289 if (!SWIG_IsOK(res1)) {
41290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41291 }
41292 arg1 = reinterpret_cast< wxValidator * >(argp1);
41293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41294 if (!SWIG_IsOK(res2)) {
41295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41296 }
41297 arg2 = reinterpret_cast< wxWindow * >(argp2);
41298 {
41299 PyThreadState* __tstate = wxPyBeginAllowThreads();
41300 result = (bool)(arg1)->Validate(arg2);
41301 wxPyEndAllowThreads(__tstate);
41302 if (PyErr_Occurred()) SWIG_fail;
41303 }
41304 {
41305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41306 }
41307 return resultobj;
41308 fail:
41309 return NULL;
41310 }
41311
41312
41313 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41314 PyObject *resultobj = 0;
41315 wxValidator *arg1 = (wxValidator *) 0 ;
41316 bool result;
41317 void *argp1 = 0 ;
41318 int res1 = 0 ;
41319 PyObject *swig_obj[1] ;
41320
41321 if (!args) SWIG_fail;
41322 swig_obj[0] = args;
41323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41324 if (!SWIG_IsOK(res1)) {
41325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41326 }
41327 arg1 = reinterpret_cast< wxValidator * >(argp1);
41328 {
41329 PyThreadState* __tstate = wxPyBeginAllowThreads();
41330 result = (bool)(arg1)->TransferToWindow();
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 {
41335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41336 }
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41344 PyObject *resultobj = 0;
41345 wxValidator *arg1 = (wxValidator *) 0 ;
41346 bool result;
41347 void *argp1 = 0 ;
41348 int res1 = 0 ;
41349 PyObject *swig_obj[1] ;
41350
41351 if (!args) SWIG_fail;
41352 swig_obj[0] = args;
41353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41354 if (!SWIG_IsOK(res1)) {
41355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41356 }
41357 arg1 = reinterpret_cast< wxValidator * >(argp1);
41358 {
41359 PyThreadState* __tstate = wxPyBeginAllowThreads();
41360 result = (bool)(arg1)->TransferFromWindow();
41361 wxPyEndAllowThreads(__tstate);
41362 if (PyErr_Occurred()) SWIG_fail;
41363 }
41364 {
41365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41366 }
41367 return resultobj;
41368 fail:
41369 return NULL;
41370 }
41371
41372
41373 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41374 PyObject *resultobj = 0;
41375 wxValidator *arg1 = (wxValidator *) 0 ;
41376 wxWindow *result = 0 ;
41377 void *argp1 = 0 ;
41378 int res1 = 0 ;
41379 PyObject *swig_obj[1] ;
41380
41381 if (!args) SWIG_fail;
41382 swig_obj[0] = args;
41383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41384 if (!SWIG_IsOK(res1)) {
41385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41386 }
41387 arg1 = reinterpret_cast< wxValidator * >(argp1);
41388 {
41389 PyThreadState* __tstate = wxPyBeginAllowThreads();
41390 result = (wxWindow *)(arg1)->GetWindow();
41391 wxPyEndAllowThreads(__tstate);
41392 if (PyErr_Occurred()) SWIG_fail;
41393 }
41394 {
41395 resultobj = wxPyMake_wxObject(result, 0);
41396 }
41397 return resultobj;
41398 fail:
41399 return NULL;
41400 }
41401
41402
41403 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41404 PyObject *resultobj = 0;
41405 wxValidator *arg1 = (wxValidator *) 0 ;
41406 wxWindow *arg2 = (wxWindow *) 0 ;
41407 void *argp1 = 0 ;
41408 int res1 = 0 ;
41409 void *argp2 = 0 ;
41410 int res2 = 0 ;
41411 PyObject * obj0 = 0 ;
41412 PyObject * obj1 = 0 ;
41413 char * kwnames[] = {
41414 (char *) "self",(char *) "window", NULL
41415 };
41416
41417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41419 if (!SWIG_IsOK(res1)) {
41420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41421 }
41422 arg1 = reinterpret_cast< wxValidator * >(argp1);
41423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41424 if (!SWIG_IsOK(res2)) {
41425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41426 }
41427 arg2 = reinterpret_cast< wxWindow * >(argp2);
41428 {
41429 PyThreadState* __tstate = wxPyBeginAllowThreads();
41430 (arg1)->SetWindow(arg2);
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 resultobj = SWIG_Py_Void();
41435 return resultobj;
41436 fail:
41437 return NULL;
41438 }
41439
41440
41441 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41442 PyObject *resultobj = 0;
41443 bool result;
41444
41445 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41446 {
41447 PyThreadState* __tstate = wxPyBeginAllowThreads();
41448 result = (bool)wxValidator::IsSilent();
41449 wxPyEndAllowThreads(__tstate);
41450 if (PyErr_Occurred()) SWIG_fail;
41451 }
41452 {
41453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41454 }
41455 return resultobj;
41456 fail:
41457 return NULL;
41458 }
41459
41460
41461 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41462 PyObject *resultobj = 0;
41463 int arg1 = (int) true ;
41464 int val1 ;
41465 int ecode1 = 0 ;
41466 PyObject * obj0 = 0 ;
41467 char * kwnames[] = {
41468 (char *) "doIt", NULL
41469 };
41470
41471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41472 if (obj0) {
41473 ecode1 = SWIG_AsVal_int(obj0, &val1);
41474 if (!SWIG_IsOK(ecode1)) {
41475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41476 }
41477 arg1 = static_cast< int >(val1);
41478 }
41479 {
41480 PyThreadState* __tstate = wxPyBeginAllowThreads();
41481 wxValidator::SetBellOnError(arg1);
41482 wxPyEndAllowThreads(__tstate);
41483 if (PyErr_Occurred()) SWIG_fail;
41484 }
41485 resultobj = SWIG_Py_Void();
41486 return resultobj;
41487 fail:
41488 return NULL;
41489 }
41490
41491
41492 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41493 PyObject *obj;
41494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41495 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41496 return SWIG_Py_Void();
41497 }
41498
41499 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41500 return SWIG_Python_InitShadowInstance(args);
41501 }
41502
41503 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41504 PyObject *resultobj = 0;
41505 wxPyValidator *result = 0 ;
41506
41507 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41508 {
41509 PyThreadState* __tstate = wxPyBeginAllowThreads();
41510 result = (wxPyValidator *)new wxPyValidator();
41511 wxPyEndAllowThreads(__tstate);
41512 if (PyErr_Occurred()) SWIG_fail;
41513 }
41514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41515 return resultobj;
41516 fail:
41517 return NULL;
41518 }
41519
41520
41521 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41522 PyObject *resultobj = 0;
41523 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41524 PyObject *arg2 = (PyObject *) 0 ;
41525 PyObject *arg3 = (PyObject *) 0 ;
41526 int arg4 = (int) true ;
41527 void *argp1 = 0 ;
41528 int res1 = 0 ;
41529 int val4 ;
41530 int ecode4 = 0 ;
41531 PyObject * obj0 = 0 ;
41532 PyObject * obj1 = 0 ;
41533 PyObject * obj2 = 0 ;
41534 PyObject * obj3 = 0 ;
41535 char * kwnames[] = {
41536 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41537 };
41538
41539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41541 if (!SWIG_IsOK(res1)) {
41542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41543 }
41544 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41545 arg2 = obj1;
41546 arg3 = obj2;
41547 if (obj3) {
41548 ecode4 = SWIG_AsVal_int(obj3, &val4);
41549 if (!SWIG_IsOK(ecode4)) {
41550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41551 }
41552 arg4 = static_cast< int >(val4);
41553 }
41554 {
41555 PyThreadState* __tstate = wxPyBeginAllowThreads();
41556 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41557 wxPyEndAllowThreads(__tstate);
41558 if (PyErr_Occurred()) SWIG_fail;
41559 }
41560 resultobj = SWIG_Py_Void();
41561 return resultobj;
41562 fail:
41563 return NULL;
41564 }
41565
41566
41567 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41568 PyObject *obj;
41569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41571 return SWIG_Py_Void();
41572 }
41573
41574 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41575 return SWIG_Python_InitShadowInstance(args);
41576 }
41577
41578 SWIGINTERN int DefaultValidator_set(PyObject *) {
41579 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41580 return 1;
41581 }
41582
41583
41584 SWIGINTERN PyObject *DefaultValidator_get(void) {
41585 PyObject *pyobj = 0;
41586
41587 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41588 return pyobj;
41589 }
41590
41591
41592 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41593 PyObject *resultobj = 0;
41594 wxString const &arg1_defvalue = wxPyEmptyString ;
41595 wxString *arg1 = (wxString *) &arg1_defvalue ;
41596 long arg2 = (long) 0 ;
41597 wxMenu *result = 0 ;
41598 bool temp1 = false ;
41599 long val2 ;
41600 int ecode2 = 0 ;
41601 PyObject * obj0 = 0 ;
41602 PyObject * obj1 = 0 ;
41603 char * kwnames[] = {
41604 (char *) "title",(char *) "style", NULL
41605 };
41606
41607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41608 if (obj0) {
41609 {
41610 arg1 = wxString_in_helper(obj0);
41611 if (arg1 == NULL) SWIG_fail;
41612 temp1 = true;
41613 }
41614 }
41615 if (obj1) {
41616 ecode2 = SWIG_AsVal_long(obj1, &val2);
41617 if (!SWIG_IsOK(ecode2)) {
41618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41619 }
41620 arg2 = static_cast< long >(val2);
41621 }
41622 {
41623 if (!wxPyCheckForApp()) SWIG_fail;
41624 PyThreadState* __tstate = wxPyBeginAllowThreads();
41625 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41626 wxPyEndAllowThreads(__tstate);
41627 if (PyErr_Occurred()) SWIG_fail;
41628 }
41629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41630 {
41631 if (temp1)
41632 delete arg1;
41633 }
41634 return resultobj;
41635 fail:
41636 {
41637 if (temp1)
41638 delete arg1;
41639 }
41640 return NULL;
41641 }
41642
41643
41644 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41645 PyObject *resultobj = 0;
41646 wxMenu *arg1 = (wxMenu *) 0 ;
41647 int arg2 ;
41648 wxString const &arg3_defvalue = wxPyEmptyString ;
41649 wxString *arg3 = (wxString *) &arg3_defvalue ;
41650 wxString const &arg4_defvalue = wxPyEmptyString ;
41651 wxString *arg4 = (wxString *) &arg4_defvalue ;
41652 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41653 wxMenuItem *result = 0 ;
41654 void *argp1 = 0 ;
41655 int res1 = 0 ;
41656 int val2 ;
41657 int ecode2 = 0 ;
41658 bool temp3 = false ;
41659 bool temp4 = false ;
41660 int val5 ;
41661 int ecode5 = 0 ;
41662 PyObject * obj0 = 0 ;
41663 PyObject * obj1 = 0 ;
41664 PyObject * obj2 = 0 ;
41665 PyObject * obj3 = 0 ;
41666 PyObject * obj4 = 0 ;
41667 char * kwnames[] = {
41668 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41669 };
41670
41671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41673 if (!SWIG_IsOK(res1)) {
41674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41675 }
41676 arg1 = reinterpret_cast< wxMenu * >(argp1);
41677 ecode2 = SWIG_AsVal_int(obj1, &val2);
41678 if (!SWIG_IsOK(ecode2)) {
41679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41680 }
41681 arg2 = static_cast< int >(val2);
41682 if (obj2) {
41683 {
41684 arg3 = wxString_in_helper(obj2);
41685 if (arg3 == NULL) SWIG_fail;
41686 temp3 = true;
41687 }
41688 }
41689 if (obj3) {
41690 {
41691 arg4 = wxString_in_helper(obj3);
41692 if (arg4 == NULL) SWIG_fail;
41693 temp4 = true;
41694 }
41695 }
41696 if (obj4) {
41697 ecode5 = SWIG_AsVal_int(obj4, &val5);
41698 if (!SWIG_IsOK(ecode5)) {
41699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41700 }
41701 arg5 = static_cast< wxItemKind >(val5);
41702 }
41703 {
41704 PyThreadState* __tstate = wxPyBeginAllowThreads();
41705 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41706 wxPyEndAllowThreads(__tstate);
41707 if (PyErr_Occurred()) SWIG_fail;
41708 }
41709 {
41710 resultobj = wxPyMake_wxObject(result, (bool)0);
41711 }
41712 {
41713 if (temp3)
41714 delete arg3;
41715 }
41716 {
41717 if (temp4)
41718 delete arg4;
41719 }
41720 return resultobj;
41721 fail:
41722 {
41723 if (temp3)
41724 delete arg3;
41725 }
41726 {
41727 if (temp4)
41728 delete arg4;
41729 }
41730 return NULL;
41731 }
41732
41733
41734 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41735 PyObject *resultobj = 0;
41736 wxMenu *arg1 = (wxMenu *) 0 ;
41737 wxMenuItem *result = 0 ;
41738 void *argp1 = 0 ;
41739 int res1 = 0 ;
41740 PyObject *swig_obj[1] ;
41741
41742 if (!args) SWIG_fail;
41743 swig_obj[0] = args;
41744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41745 if (!SWIG_IsOK(res1)) {
41746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41747 }
41748 arg1 = reinterpret_cast< wxMenu * >(argp1);
41749 {
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = (wxMenuItem *)(arg1)->AppendSeparator();
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 {
41756 resultobj = wxPyMake_wxObject(result, (bool)0);
41757 }
41758 return resultobj;
41759 fail:
41760 return NULL;
41761 }
41762
41763
41764 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41765 PyObject *resultobj = 0;
41766 wxMenu *arg1 = (wxMenu *) 0 ;
41767 int arg2 ;
41768 wxString *arg3 = 0 ;
41769 wxString const &arg4_defvalue = wxPyEmptyString ;
41770 wxString *arg4 = (wxString *) &arg4_defvalue ;
41771 wxMenuItem *result = 0 ;
41772 void *argp1 = 0 ;
41773 int res1 = 0 ;
41774 int val2 ;
41775 int ecode2 = 0 ;
41776 bool temp3 = false ;
41777 bool temp4 = false ;
41778 PyObject * obj0 = 0 ;
41779 PyObject * obj1 = 0 ;
41780 PyObject * obj2 = 0 ;
41781 PyObject * obj3 = 0 ;
41782 char * kwnames[] = {
41783 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41784 };
41785
41786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41788 if (!SWIG_IsOK(res1)) {
41789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41790 }
41791 arg1 = reinterpret_cast< wxMenu * >(argp1);
41792 ecode2 = SWIG_AsVal_int(obj1, &val2);
41793 if (!SWIG_IsOK(ecode2)) {
41794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41795 }
41796 arg2 = static_cast< int >(val2);
41797 {
41798 arg3 = wxString_in_helper(obj2);
41799 if (arg3 == NULL) SWIG_fail;
41800 temp3 = true;
41801 }
41802 if (obj3) {
41803 {
41804 arg4 = wxString_in_helper(obj3);
41805 if (arg4 == NULL) SWIG_fail;
41806 temp4 = true;
41807 }
41808 }
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41812 wxPyEndAllowThreads(__tstate);
41813 if (PyErr_Occurred()) SWIG_fail;
41814 }
41815 {
41816 resultobj = wxPyMake_wxObject(result, (bool)0);
41817 }
41818 {
41819 if (temp3)
41820 delete arg3;
41821 }
41822 {
41823 if (temp4)
41824 delete arg4;
41825 }
41826 return resultobj;
41827 fail:
41828 {
41829 if (temp3)
41830 delete arg3;
41831 }
41832 {
41833 if (temp4)
41834 delete arg4;
41835 }
41836 return NULL;
41837 }
41838
41839
41840 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41841 PyObject *resultobj = 0;
41842 wxMenu *arg1 = (wxMenu *) 0 ;
41843 int arg2 ;
41844 wxString *arg3 = 0 ;
41845 wxString const &arg4_defvalue = wxPyEmptyString ;
41846 wxString *arg4 = (wxString *) &arg4_defvalue ;
41847 wxMenuItem *result = 0 ;
41848 void *argp1 = 0 ;
41849 int res1 = 0 ;
41850 int val2 ;
41851 int ecode2 = 0 ;
41852 bool temp3 = false ;
41853 bool temp4 = false ;
41854 PyObject * obj0 = 0 ;
41855 PyObject * obj1 = 0 ;
41856 PyObject * obj2 = 0 ;
41857 PyObject * obj3 = 0 ;
41858 char * kwnames[] = {
41859 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41860 };
41861
41862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41864 if (!SWIG_IsOK(res1)) {
41865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41866 }
41867 arg1 = reinterpret_cast< wxMenu * >(argp1);
41868 ecode2 = SWIG_AsVal_int(obj1, &val2);
41869 if (!SWIG_IsOK(ecode2)) {
41870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41871 }
41872 arg2 = static_cast< int >(val2);
41873 {
41874 arg3 = wxString_in_helper(obj2);
41875 if (arg3 == NULL) SWIG_fail;
41876 temp3 = true;
41877 }
41878 if (obj3) {
41879 {
41880 arg4 = wxString_in_helper(obj3);
41881 if (arg4 == NULL) SWIG_fail;
41882 temp4 = true;
41883 }
41884 }
41885 {
41886 PyThreadState* __tstate = wxPyBeginAllowThreads();
41887 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41888 wxPyEndAllowThreads(__tstate);
41889 if (PyErr_Occurred()) SWIG_fail;
41890 }
41891 {
41892 resultobj = wxPyMake_wxObject(result, (bool)0);
41893 }
41894 {
41895 if (temp3)
41896 delete arg3;
41897 }
41898 {
41899 if (temp4)
41900 delete arg4;
41901 }
41902 return resultobj;
41903 fail:
41904 {
41905 if (temp3)
41906 delete arg3;
41907 }
41908 {
41909 if (temp4)
41910 delete arg4;
41911 }
41912 return NULL;
41913 }
41914
41915
41916 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41917 PyObject *resultobj = 0;
41918 wxMenu *arg1 = (wxMenu *) 0 ;
41919 int arg2 ;
41920 wxString *arg3 = 0 ;
41921 wxMenu *arg4 = (wxMenu *) 0 ;
41922 wxString const &arg5_defvalue = wxPyEmptyString ;
41923 wxString *arg5 = (wxString *) &arg5_defvalue ;
41924 wxMenuItem *result = 0 ;
41925 void *argp1 = 0 ;
41926 int res1 = 0 ;
41927 int val2 ;
41928 int ecode2 = 0 ;
41929 bool temp3 = false ;
41930 void *argp4 = 0 ;
41931 int res4 = 0 ;
41932 bool temp5 = false ;
41933 PyObject * obj0 = 0 ;
41934 PyObject * obj1 = 0 ;
41935 PyObject * obj2 = 0 ;
41936 PyObject * obj3 = 0 ;
41937 PyObject * obj4 = 0 ;
41938 char * kwnames[] = {
41939 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41940 };
41941
41942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41944 if (!SWIG_IsOK(res1)) {
41945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41946 }
41947 arg1 = reinterpret_cast< wxMenu * >(argp1);
41948 ecode2 = SWIG_AsVal_int(obj1, &val2);
41949 if (!SWIG_IsOK(ecode2)) {
41950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41951 }
41952 arg2 = static_cast< int >(val2);
41953 {
41954 arg3 = wxString_in_helper(obj2);
41955 if (arg3 == NULL) SWIG_fail;
41956 temp3 = true;
41957 }
41958 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41959 if (!SWIG_IsOK(res4)) {
41960 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41961 }
41962 arg4 = reinterpret_cast< wxMenu * >(argp4);
41963 if (obj4) {
41964 {
41965 arg5 = wxString_in_helper(obj4);
41966 if (arg5 == NULL) SWIG_fail;
41967 temp5 = true;
41968 }
41969 }
41970 {
41971 PyThreadState* __tstate = wxPyBeginAllowThreads();
41972 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
41973 wxPyEndAllowThreads(__tstate);
41974 if (PyErr_Occurred()) SWIG_fail;
41975 }
41976 {
41977 resultobj = wxPyMake_wxObject(result, (bool)0);
41978 }
41979 {
41980 if (temp3)
41981 delete arg3;
41982 }
41983 {
41984 if (temp5)
41985 delete arg5;
41986 }
41987 return resultobj;
41988 fail:
41989 {
41990 if (temp3)
41991 delete arg3;
41992 }
41993 {
41994 if (temp5)
41995 delete arg5;
41996 }
41997 return NULL;
41998 }
41999
42000
42001 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42002 PyObject *resultobj = 0;
42003 wxMenu *arg1 = (wxMenu *) 0 ;
42004 wxMenu *arg2 = (wxMenu *) 0 ;
42005 wxString *arg3 = 0 ;
42006 wxString const &arg4_defvalue = wxPyEmptyString ;
42007 wxString *arg4 = (wxString *) &arg4_defvalue ;
42008 wxMenuItem *result = 0 ;
42009 void *argp1 = 0 ;
42010 int res1 = 0 ;
42011 void *argp2 = 0 ;
42012 int res2 = 0 ;
42013 bool temp3 = false ;
42014 bool temp4 = false ;
42015 PyObject * obj0 = 0 ;
42016 PyObject * obj1 = 0 ;
42017 PyObject * obj2 = 0 ;
42018 PyObject * obj3 = 0 ;
42019 char * kwnames[] = {
42020 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42021 };
42022
42023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42025 if (!SWIG_IsOK(res1)) {
42026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42027 }
42028 arg1 = reinterpret_cast< wxMenu * >(argp1);
42029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42030 if (!SWIG_IsOK(res2)) {
42031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42032 }
42033 arg2 = reinterpret_cast< wxMenu * >(argp2);
42034 {
42035 arg3 = wxString_in_helper(obj2);
42036 if (arg3 == NULL) SWIG_fail;
42037 temp3 = true;
42038 }
42039 if (obj3) {
42040 {
42041 arg4 = wxString_in_helper(obj3);
42042 if (arg4 == NULL) SWIG_fail;
42043 temp4 = true;
42044 }
42045 }
42046 {
42047 PyThreadState* __tstate = wxPyBeginAllowThreads();
42048 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42049 wxPyEndAllowThreads(__tstate);
42050 if (PyErr_Occurred()) SWIG_fail;
42051 }
42052 {
42053 resultobj = wxPyMake_wxObject(result, (bool)0);
42054 }
42055 {
42056 if (temp3)
42057 delete arg3;
42058 }
42059 {
42060 if (temp4)
42061 delete arg4;
42062 }
42063 return resultobj;
42064 fail:
42065 {
42066 if (temp3)
42067 delete arg3;
42068 }
42069 {
42070 if (temp4)
42071 delete arg4;
42072 }
42073 return NULL;
42074 }
42075
42076
42077 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42078 PyObject *resultobj = 0;
42079 wxMenu *arg1 = (wxMenu *) 0 ;
42080 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42081 wxMenuItem *result = 0 ;
42082 void *argp1 = 0 ;
42083 int res1 = 0 ;
42084 int res2 = 0 ;
42085 PyObject * obj0 = 0 ;
42086 PyObject * obj1 = 0 ;
42087 char * kwnames[] = {
42088 (char *) "self",(char *) "item", NULL
42089 };
42090
42091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42093 if (!SWIG_IsOK(res1)) {
42094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42095 }
42096 arg1 = reinterpret_cast< wxMenu * >(argp1);
42097 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42098 if (!SWIG_IsOK(res2)) {
42099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42100 }
42101 {
42102 PyThreadState* __tstate = wxPyBeginAllowThreads();
42103 result = (wxMenuItem *)(arg1)->Append(arg2);
42104 wxPyEndAllowThreads(__tstate);
42105 if (PyErr_Occurred()) SWIG_fail;
42106 }
42107 {
42108 resultobj = wxPyMake_wxObject(result, (bool)0);
42109 }
42110 return resultobj;
42111 fail:
42112 return NULL;
42113 }
42114
42115
42116 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42117 PyObject *resultobj = 0;
42118 wxMenu *arg1 = (wxMenu *) 0 ;
42119 size_t arg2 ;
42120 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42121 wxMenuItem *result = 0 ;
42122 void *argp1 = 0 ;
42123 int res1 = 0 ;
42124 size_t val2 ;
42125 int ecode2 = 0 ;
42126 int res3 = 0 ;
42127 PyObject * obj0 = 0 ;
42128 PyObject * obj1 = 0 ;
42129 PyObject * obj2 = 0 ;
42130 char * kwnames[] = {
42131 (char *) "self",(char *) "pos",(char *) "item", NULL
42132 };
42133
42134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42136 if (!SWIG_IsOK(res1)) {
42137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42138 }
42139 arg1 = reinterpret_cast< wxMenu * >(argp1);
42140 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42141 if (!SWIG_IsOK(ecode2)) {
42142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42143 }
42144 arg2 = static_cast< size_t >(val2);
42145 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42146 if (!SWIG_IsOK(res3)) {
42147 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42148 }
42149 {
42150 PyThreadState* __tstate = wxPyBeginAllowThreads();
42151 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42152 wxPyEndAllowThreads(__tstate);
42153 if (PyErr_Occurred()) SWIG_fail;
42154 }
42155 {
42156 resultobj = wxPyMake_wxObject(result, (bool)0);
42157 }
42158 return resultobj;
42159 fail:
42160 return NULL;
42161 }
42162
42163
42164 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42165 PyObject *resultobj = 0;
42166 wxMenu *arg1 = (wxMenu *) 0 ;
42167 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42168 wxMenuItem *result = 0 ;
42169 void *argp1 = 0 ;
42170 int res1 = 0 ;
42171 int res2 = 0 ;
42172 PyObject * obj0 = 0 ;
42173 PyObject * obj1 = 0 ;
42174 char * kwnames[] = {
42175 (char *) "self",(char *) "item", NULL
42176 };
42177
42178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42180 if (!SWIG_IsOK(res1)) {
42181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42182 }
42183 arg1 = reinterpret_cast< wxMenu * >(argp1);
42184 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42185 if (!SWIG_IsOK(res2)) {
42186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42187 }
42188 {
42189 PyThreadState* __tstate = wxPyBeginAllowThreads();
42190 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42191 wxPyEndAllowThreads(__tstate);
42192 if (PyErr_Occurred()) SWIG_fail;
42193 }
42194 {
42195 resultobj = wxPyMake_wxObject(result, (bool)0);
42196 }
42197 return resultobj;
42198 fail:
42199 return NULL;
42200 }
42201
42202
42203 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42204 PyObject *resultobj = 0;
42205 wxMenu *arg1 = (wxMenu *) 0 ;
42206 void *argp1 = 0 ;
42207 int res1 = 0 ;
42208 PyObject *swig_obj[1] ;
42209
42210 if (!args) SWIG_fail;
42211 swig_obj[0] = args;
42212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42213 if (!SWIG_IsOK(res1)) {
42214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42215 }
42216 arg1 = reinterpret_cast< wxMenu * >(argp1);
42217 {
42218 PyThreadState* __tstate = wxPyBeginAllowThreads();
42219 (arg1)->Break();
42220 wxPyEndAllowThreads(__tstate);
42221 if (PyErr_Occurred()) SWIG_fail;
42222 }
42223 resultobj = SWIG_Py_Void();
42224 return resultobj;
42225 fail:
42226 return NULL;
42227 }
42228
42229
42230 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42231 PyObject *resultobj = 0;
42232 wxMenu *arg1 = (wxMenu *) 0 ;
42233 size_t arg2 ;
42234 int arg3 ;
42235 wxString const &arg4_defvalue = wxPyEmptyString ;
42236 wxString *arg4 = (wxString *) &arg4_defvalue ;
42237 wxString const &arg5_defvalue = wxPyEmptyString ;
42238 wxString *arg5 = (wxString *) &arg5_defvalue ;
42239 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42240 wxMenuItem *result = 0 ;
42241 void *argp1 = 0 ;
42242 int res1 = 0 ;
42243 size_t val2 ;
42244 int ecode2 = 0 ;
42245 int val3 ;
42246 int ecode3 = 0 ;
42247 bool temp4 = false ;
42248 bool temp5 = false ;
42249 int val6 ;
42250 int ecode6 = 0 ;
42251 PyObject * obj0 = 0 ;
42252 PyObject * obj1 = 0 ;
42253 PyObject * obj2 = 0 ;
42254 PyObject * obj3 = 0 ;
42255 PyObject * obj4 = 0 ;
42256 PyObject * obj5 = 0 ;
42257 char * kwnames[] = {
42258 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42259 };
42260
42261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42263 if (!SWIG_IsOK(res1)) {
42264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42265 }
42266 arg1 = reinterpret_cast< wxMenu * >(argp1);
42267 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42268 if (!SWIG_IsOK(ecode2)) {
42269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42270 }
42271 arg2 = static_cast< size_t >(val2);
42272 ecode3 = SWIG_AsVal_int(obj2, &val3);
42273 if (!SWIG_IsOK(ecode3)) {
42274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42275 }
42276 arg3 = static_cast< int >(val3);
42277 if (obj3) {
42278 {
42279 arg4 = wxString_in_helper(obj3);
42280 if (arg4 == NULL) SWIG_fail;
42281 temp4 = true;
42282 }
42283 }
42284 if (obj4) {
42285 {
42286 arg5 = wxString_in_helper(obj4);
42287 if (arg5 == NULL) SWIG_fail;
42288 temp5 = true;
42289 }
42290 }
42291 if (obj5) {
42292 ecode6 = SWIG_AsVal_int(obj5, &val6);
42293 if (!SWIG_IsOK(ecode6)) {
42294 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42295 }
42296 arg6 = static_cast< wxItemKind >(val6);
42297 }
42298 {
42299 PyThreadState* __tstate = wxPyBeginAllowThreads();
42300 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 {
42305 resultobj = wxPyMake_wxObject(result, (bool)0);
42306 }
42307 {
42308 if (temp4)
42309 delete arg4;
42310 }
42311 {
42312 if (temp5)
42313 delete arg5;
42314 }
42315 return resultobj;
42316 fail:
42317 {
42318 if (temp4)
42319 delete arg4;
42320 }
42321 {
42322 if (temp5)
42323 delete arg5;
42324 }
42325 return NULL;
42326 }
42327
42328
42329 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42330 PyObject *resultobj = 0;
42331 wxMenu *arg1 = (wxMenu *) 0 ;
42332 size_t arg2 ;
42333 wxMenuItem *result = 0 ;
42334 void *argp1 = 0 ;
42335 int res1 = 0 ;
42336 size_t val2 ;
42337 int ecode2 = 0 ;
42338 PyObject * obj0 = 0 ;
42339 PyObject * obj1 = 0 ;
42340 char * kwnames[] = {
42341 (char *) "self",(char *) "pos", NULL
42342 };
42343
42344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42346 if (!SWIG_IsOK(res1)) {
42347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42348 }
42349 arg1 = reinterpret_cast< wxMenu * >(argp1);
42350 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42351 if (!SWIG_IsOK(ecode2)) {
42352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42353 }
42354 arg2 = static_cast< size_t >(val2);
42355 {
42356 PyThreadState* __tstate = wxPyBeginAllowThreads();
42357 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42358 wxPyEndAllowThreads(__tstate);
42359 if (PyErr_Occurred()) SWIG_fail;
42360 }
42361 {
42362 resultobj = wxPyMake_wxObject(result, (bool)0);
42363 }
42364 return resultobj;
42365 fail:
42366 return NULL;
42367 }
42368
42369
42370 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42371 PyObject *resultobj = 0;
42372 wxMenu *arg1 = (wxMenu *) 0 ;
42373 size_t arg2 ;
42374 int arg3 ;
42375 wxString *arg4 = 0 ;
42376 wxString const &arg5_defvalue = wxPyEmptyString ;
42377 wxString *arg5 = (wxString *) &arg5_defvalue ;
42378 wxMenuItem *result = 0 ;
42379 void *argp1 = 0 ;
42380 int res1 = 0 ;
42381 size_t val2 ;
42382 int ecode2 = 0 ;
42383 int val3 ;
42384 int ecode3 = 0 ;
42385 bool temp4 = false ;
42386 bool temp5 = false ;
42387 PyObject * obj0 = 0 ;
42388 PyObject * obj1 = 0 ;
42389 PyObject * obj2 = 0 ;
42390 PyObject * obj3 = 0 ;
42391 PyObject * obj4 = 0 ;
42392 char * kwnames[] = {
42393 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42394 };
42395
42396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42398 if (!SWIG_IsOK(res1)) {
42399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42400 }
42401 arg1 = reinterpret_cast< wxMenu * >(argp1);
42402 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42403 if (!SWIG_IsOK(ecode2)) {
42404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42405 }
42406 arg2 = static_cast< size_t >(val2);
42407 ecode3 = SWIG_AsVal_int(obj2, &val3);
42408 if (!SWIG_IsOK(ecode3)) {
42409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42410 }
42411 arg3 = static_cast< int >(val3);
42412 {
42413 arg4 = wxString_in_helper(obj3);
42414 if (arg4 == NULL) SWIG_fail;
42415 temp4 = true;
42416 }
42417 if (obj4) {
42418 {
42419 arg5 = wxString_in_helper(obj4);
42420 if (arg5 == NULL) SWIG_fail;
42421 temp5 = true;
42422 }
42423 }
42424 {
42425 PyThreadState* __tstate = wxPyBeginAllowThreads();
42426 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42427 wxPyEndAllowThreads(__tstate);
42428 if (PyErr_Occurred()) SWIG_fail;
42429 }
42430 {
42431 resultobj = wxPyMake_wxObject(result, (bool)0);
42432 }
42433 {
42434 if (temp4)
42435 delete arg4;
42436 }
42437 {
42438 if (temp5)
42439 delete arg5;
42440 }
42441 return resultobj;
42442 fail:
42443 {
42444 if (temp4)
42445 delete arg4;
42446 }
42447 {
42448 if (temp5)
42449 delete arg5;
42450 }
42451 return NULL;
42452 }
42453
42454
42455 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42456 PyObject *resultobj = 0;
42457 wxMenu *arg1 = (wxMenu *) 0 ;
42458 size_t arg2 ;
42459 int arg3 ;
42460 wxString *arg4 = 0 ;
42461 wxString const &arg5_defvalue = wxPyEmptyString ;
42462 wxString *arg5 = (wxString *) &arg5_defvalue ;
42463 wxMenuItem *result = 0 ;
42464 void *argp1 = 0 ;
42465 int res1 = 0 ;
42466 size_t val2 ;
42467 int ecode2 = 0 ;
42468 int val3 ;
42469 int ecode3 = 0 ;
42470 bool temp4 = false ;
42471 bool temp5 = false ;
42472 PyObject * obj0 = 0 ;
42473 PyObject * obj1 = 0 ;
42474 PyObject * obj2 = 0 ;
42475 PyObject * obj3 = 0 ;
42476 PyObject * obj4 = 0 ;
42477 char * kwnames[] = {
42478 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42479 };
42480
42481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42483 if (!SWIG_IsOK(res1)) {
42484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42485 }
42486 arg1 = reinterpret_cast< wxMenu * >(argp1);
42487 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42488 if (!SWIG_IsOK(ecode2)) {
42489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42490 }
42491 arg2 = static_cast< size_t >(val2);
42492 ecode3 = SWIG_AsVal_int(obj2, &val3);
42493 if (!SWIG_IsOK(ecode3)) {
42494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42495 }
42496 arg3 = static_cast< int >(val3);
42497 {
42498 arg4 = wxString_in_helper(obj3);
42499 if (arg4 == NULL) SWIG_fail;
42500 temp4 = true;
42501 }
42502 if (obj4) {
42503 {
42504 arg5 = wxString_in_helper(obj4);
42505 if (arg5 == NULL) SWIG_fail;
42506 temp5 = true;
42507 }
42508 }
42509 {
42510 PyThreadState* __tstate = wxPyBeginAllowThreads();
42511 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42512 wxPyEndAllowThreads(__tstate);
42513 if (PyErr_Occurred()) SWIG_fail;
42514 }
42515 {
42516 resultobj = wxPyMake_wxObject(result, (bool)0);
42517 }
42518 {
42519 if (temp4)
42520 delete arg4;
42521 }
42522 {
42523 if (temp5)
42524 delete arg5;
42525 }
42526 return resultobj;
42527 fail:
42528 {
42529 if (temp4)
42530 delete arg4;
42531 }
42532 {
42533 if (temp5)
42534 delete arg5;
42535 }
42536 return NULL;
42537 }
42538
42539
42540 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42541 PyObject *resultobj = 0;
42542 wxMenu *arg1 = (wxMenu *) 0 ;
42543 size_t arg2 ;
42544 int arg3 ;
42545 wxString *arg4 = 0 ;
42546 wxMenu *arg5 = (wxMenu *) 0 ;
42547 wxString const &arg6_defvalue = wxPyEmptyString ;
42548 wxString *arg6 = (wxString *) &arg6_defvalue ;
42549 wxMenuItem *result = 0 ;
42550 void *argp1 = 0 ;
42551 int res1 = 0 ;
42552 size_t val2 ;
42553 int ecode2 = 0 ;
42554 int val3 ;
42555 int ecode3 = 0 ;
42556 bool temp4 = false ;
42557 void *argp5 = 0 ;
42558 int res5 = 0 ;
42559 bool temp6 = false ;
42560 PyObject * obj0 = 0 ;
42561 PyObject * obj1 = 0 ;
42562 PyObject * obj2 = 0 ;
42563 PyObject * obj3 = 0 ;
42564 PyObject * obj4 = 0 ;
42565 PyObject * obj5 = 0 ;
42566 char * kwnames[] = {
42567 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42568 };
42569
42570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42572 if (!SWIG_IsOK(res1)) {
42573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42574 }
42575 arg1 = reinterpret_cast< wxMenu * >(argp1);
42576 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42577 if (!SWIG_IsOK(ecode2)) {
42578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42579 }
42580 arg2 = static_cast< size_t >(val2);
42581 ecode3 = SWIG_AsVal_int(obj2, &val3);
42582 if (!SWIG_IsOK(ecode3)) {
42583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42584 }
42585 arg3 = static_cast< int >(val3);
42586 {
42587 arg4 = wxString_in_helper(obj3);
42588 if (arg4 == NULL) SWIG_fail;
42589 temp4 = true;
42590 }
42591 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42592 if (!SWIG_IsOK(res5)) {
42593 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42594 }
42595 arg5 = reinterpret_cast< wxMenu * >(argp5);
42596 if (obj5) {
42597 {
42598 arg6 = wxString_in_helper(obj5);
42599 if (arg6 == NULL) SWIG_fail;
42600 temp6 = true;
42601 }
42602 }
42603 {
42604 PyThreadState* __tstate = wxPyBeginAllowThreads();
42605 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42606 wxPyEndAllowThreads(__tstate);
42607 if (PyErr_Occurred()) SWIG_fail;
42608 }
42609 {
42610 resultobj = wxPyMake_wxObject(result, (bool)0);
42611 }
42612 {
42613 if (temp4)
42614 delete arg4;
42615 }
42616 {
42617 if (temp6)
42618 delete arg6;
42619 }
42620 return resultobj;
42621 fail:
42622 {
42623 if (temp4)
42624 delete arg4;
42625 }
42626 {
42627 if (temp6)
42628 delete arg6;
42629 }
42630 return NULL;
42631 }
42632
42633
42634 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42635 PyObject *resultobj = 0;
42636 wxMenu *arg1 = (wxMenu *) 0 ;
42637 int arg2 ;
42638 wxString const &arg3_defvalue = wxPyEmptyString ;
42639 wxString *arg3 = (wxString *) &arg3_defvalue ;
42640 wxString const &arg4_defvalue = wxPyEmptyString ;
42641 wxString *arg4 = (wxString *) &arg4_defvalue ;
42642 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42643 wxMenuItem *result = 0 ;
42644 void *argp1 = 0 ;
42645 int res1 = 0 ;
42646 int val2 ;
42647 int ecode2 = 0 ;
42648 bool temp3 = false ;
42649 bool temp4 = false ;
42650 int val5 ;
42651 int ecode5 = 0 ;
42652 PyObject * obj0 = 0 ;
42653 PyObject * obj1 = 0 ;
42654 PyObject * obj2 = 0 ;
42655 PyObject * obj3 = 0 ;
42656 PyObject * obj4 = 0 ;
42657 char * kwnames[] = {
42658 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42659 };
42660
42661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42663 if (!SWIG_IsOK(res1)) {
42664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42665 }
42666 arg1 = reinterpret_cast< wxMenu * >(argp1);
42667 ecode2 = SWIG_AsVal_int(obj1, &val2);
42668 if (!SWIG_IsOK(ecode2)) {
42669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42670 }
42671 arg2 = static_cast< int >(val2);
42672 if (obj2) {
42673 {
42674 arg3 = wxString_in_helper(obj2);
42675 if (arg3 == NULL) SWIG_fail;
42676 temp3 = true;
42677 }
42678 }
42679 if (obj3) {
42680 {
42681 arg4 = wxString_in_helper(obj3);
42682 if (arg4 == NULL) SWIG_fail;
42683 temp4 = true;
42684 }
42685 }
42686 if (obj4) {
42687 ecode5 = SWIG_AsVal_int(obj4, &val5);
42688 if (!SWIG_IsOK(ecode5)) {
42689 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42690 }
42691 arg5 = static_cast< wxItemKind >(val5);
42692 }
42693 {
42694 PyThreadState* __tstate = wxPyBeginAllowThreads();
42695 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42696 wxPyEndAllowThreads(__tstate);
42697 if (PyErr_Occurred()) SWIG_fail;
42698 }
42699 {
42700 resultobj = wxPyMake_wxObject(result, (bool)0);
42701 }
42702 {
42703 if (temp3)
42704 delete arg3;
42705 }
42706 {
42707 if (temp4)
42708 delete arg4;
42709 }
42710 return resultobj;
42711 fail:
42712 {
42713 if (temp3)
42714 delete arg3;
42715 }
42716 {
42717 if (temp4)
42718 delete arg4;
42719 }
42720 return NULL;
42721 }
42722
42723
42724 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42725 PyObject *resultobj = 0;
42726 wxMenu *arg1 = (wxMenu *) 0 ;
42727 wxMenuItem *result = 0 ;
42728 void *argp1 = 0 ;
42729 int res1 = 0 ;
42730 PyObject *swig_obj[1] ;
42731
42732 if (!args) SWIG_fail;
42733 swig_obj[0] = args;
42734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42735 if (!SWIG_IsOK(res1)) {
42736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42737 }
42738 arg1 = reinterpret_cast< wxMenu * >(argp1);
42739 {
42740 PyThreadState* __tstate = wxPyBeginAllowThreads();
42741 result = (wxMenuItem *)(arg1)->PrependSeparator();
42742 wxPyEndAllowThreads(__tstate);
42743 if (PyErr_Occurred()) SWIG_fail;
42744 }
42745 {
42746 resultobj = wxPyMake_wxObject(result, (bool)0);
42747 }
42748 return resultobj;
42749 fail:
42750 return NULL;
42751 }
42752
42753
42754 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42755 PyObject *resultobj = 0;
42756 wxMenu *arg1 = (wxMenu *) 0 ;
42757 int arg2 ;
42758 wxString *arg3 = 0 ;
42759 wxString const &arg4_defvalue = wxPyEmptyString ;
42760 wxString *arg4 = (wxString *) &arg4_defvalue ;
42761 wxMenuItem *result = 0 ;
42762 void *argp1 = 0 ;
42763 int res1 = 0 ;
42764 int val2 ;
42765 int ecode2 = 0 ;
42766 bool temp3 = false ;
42767 bool temp4 = false ;
42768 PyObject * obj0 = 0 ;
42769 PyObject * obj1 = 0 ;
42770 PyObject * obj2 = 0 ;
42771 PyObject * obj3 = 0 ;
42772 char * kwnames[] = {
42773 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42774 };
42775
42776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42778 if (!SWIG_IsOK(res1)) {
42779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42780 }
42781 arg1 = reinterpret_cast< wxMenu * >(argp1);
42782 ecode2 = SWIG_AsVal_int(obj1, &val2);
42783 if (!SWIG_IsOK(ecode2)) {
42784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42785 }
42786 arg2 = static_cast< int >(val2);
42787 {
42788 arg3 = wxString_in_helper(obj2);
42789 if (arg3 == NULL) SWIG_fail;
42790 temp3 = true;
42791 }
42792 if (obj3) {
42793 {
42794 arg4 = wxString_in_helper(obj3);
42795 if (arg4 == NULL) SWIG_fail;
42796 temp4 = true;
42797 }
42798 }
42799 {
42800 PyThreadState* __tstate = wxPyBeginAllowThreads();
42801 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42802 wxPyEndAllowThreads(__tstate);
42803 if (PyErr_Occurred()) SWIG_fail;
42804 }
42805 {
42806 resultobj = wxPyMake_wxObject(result, (bool)0);
42807 }
42808 {
42809 if (temp3)
42810 delete arg3;
42811 }
42812 {
42813 if (temp4)
42814 delete arg4;
42815 }
42816 return resultobj;
42817 fail:
42818 {
42819 if (temp3)
42820 delete arg3;
42821 }
42822 {
42823 if (temp4)
42824 delete arg4;
42825 }
42826 return NULL;
42827 }
42828
42829
42830 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42831 PyObject *resultobj = 0;
42832 wxMenu *arg1 = (wxMenu *) 0 ;
42833 int arg2 ;
42834 wxString *arg3 = 0 ;
42835 wxString const &arg4_defvalue = wxPyEmptyString ;
42836 wxString *arg4 = (wxString *) &arg4_defvalue ;
42837 wxMenuItem *result = 0 ;
42838 void *argp1 = 0 ;
42839 int res1 = 0 ;
42840 int val2 ;
42841 int ecode2 = 0 ;
42842 bool temp3 = false ;
42843 bool temp4 = false ;
42844 PyObject * obj0 = 0 ;
42845 PyObject * obj1 = 0 ;
42846 PyObject * obj2 = 0 ;
42847 PyObject * obj3 = 0 ;
42848 char * kwnames[] = {
42849 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42850 };
42851
42852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42854 if (!SWIG_IsOK(res1)) {
42855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42856 }
42857 arg1 = reinterpret_cast< wxMenu * >(argp1);
42858 ecode2 = SWIG_AsVal_int(obj1, &val2);
42859 if (!SWIG_IsOK(ecode2)) {
42860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42861 }
42862 arg2 = static_cast< int >(val2);
42863 {
42864 arg3 = wxString_in_helper(obj2);
42865 if (arg3 == NULL) SWIG_fail;
42866 temp3 = true;
42867 }
42868 if (obj3) {
42869 {
42870 arg4 = wxString_in_helper(obj3);
42871 if (arg4 == NULL) SWIG_fail;
42872 temp4 = true;
42873 }
42874 }
42875 {
42876 PyThreadState* __tstate = wxPyBeginAllowThreads();
42877 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42878 wxPyEndAllowThreads(__tstate);
42879 if (PyErr_Occurred()) SWIG_fail;
42880 }
42881 {
42882 resultobj = wxPyMake_wxObject(result, (bool)0);
42883 }
42884 {
42885 if (temp3)
42886 delete arg3;
42887 }
42888 {
42889 if (temp4)
42890 delete arg4;
42891 }
42892 return resultobj;
42893 fail:
42894 {
42895 if (temp3)
42896 delete arg3;
42897 }
42898 {
42899 if (temp4)
42900 delete arg4;
42901 }
42902 return NULL;
42903 }
42904
42905
42906 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42907 PyObject *resultobj = 0;
42908 wxMenu *arg1 = (wxMenu *) 0 ;
42909 int arg2 ;
42910 wxString *arg3 = 0 ;
42911 wxMenu *arg4 = (wxMenu *) 0 ;
42912 wxString const &arg5_defvalue = wxPyEmptyString ;
42913 wxString *arg5 = (wxString *) &arg5_defvalue ;
42914 wxMenuItem *result = 0 ;
42915 void *argp1 = 0 ;
42916 int res1 = 0 ;
42917 int val2 ;
42918 int ecode2 = 0 ;
42919 bool temp3 = false ;
42920 void *argp4 = 0 ;
42921 int res4 = 0 ;
42922 bool temp5 = false ;
42923 PyObject * obj0 = 0 ;
42924 PyObject * obj1 = 0 ;
42925 PyObject * obj2 = 0 ;
42926 PyObject * obj3 = 0 ;
42927 PyObject * obj4 = 0 ;
42928 char * kwnames[] = {
42929 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42930 };
42931
42932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42934 if (!SWIG_IsOK(res1)) {
42935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42936 }
42937 arg1 = reinterpret_cast< wxMenu * >(argp1);
42938 ecode2 = SWIG_AsVal_int(obj1, &val2);
42939 if (!SWIG_IsOK(ecode2)) {
42940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42941 }
42942 arg2 = static_cast< int >(val2);
42943 {
42944 arg3 = wxString_in_helper(obj2);
42945 if (arg3 == NULL) SWIG_fail;
42946 temp3 = true;
42947 }
42948 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42949 if (!SWIG_IsOK(res4)) {
42950 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42951 }
42952 arg4 = reinterpret_cast< wxMenu * >(argp4);
42953 if (obj4) {
42954 {
42955 arg5 = wxString_in_helper(obj4);
42956 if (arg5 == NULL) SWIG_fail;
42957 temp5 = true;
42958 }
42959 }
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42963 wxPyEndAllowThreads(__tstate);
42964 if (PyErr_Occurred()) SWIG_fail;
42965 }
42966 {
42967 resultobj = wxPyMake_wxObject(result, (bool)0);
42968 }
42969 {
42970 if (temp3)
42971 delete arg3;
42972 }
42973 {
42974 if (temp5)
42975 delete arg5;
42976 }
42977 return resultobj;
42978 fail:
42979 {
42980 if (temp3)
42981 delete arg3;
42982 }
42983 {
42984 if (temp5)
42985 delete arg5;
42986 }
42987 return NULL;
42988 }
42989
42990
42991 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42992 PyObject *resultobj = 0;
42993 wxMenu *arg1 = (wxMenu *) 0 ;
42994 int arg2 ;
42995 wxMenuItem *result = 0 ;
42996 void *argp1 = 0 ;
42997 int res1 = 0 ;
42998 int val2 ;
42999 int ecode2 = 0 ;
43000 PyObject * obj0 = 0 ;
43001 PyObject * obj1 = 0 ;
43002 char * kwnames[] = {
43003 (char *) "self",(char *) "id", NULL
43004 };
43005
43006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43008 if (!SWIG_IsOK(res1)) {
43009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43010 }
43011 arg1 = reinterpret_cast< wxMenu * >(argp1);
43012 ecode2 = SWIG_AsVal_int(obj1, &val2);
43013 if (!SWIG_IsOK(ecode2)) {
43014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43015 }
43016 arg2 = static_cast< int >(val2);
43017 {
43018 PyThreadState* __tstate = wxPyBeginAllowThreads();
43019 result = (wxMenuItem *)(arg1)->Remove(arg2);
43020 wxPyEndAllowThreads(__tstate);
43021 if (PyErr_Occurred()) SWIG_fail;
43022 }
43023 {
43024 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43025 }
43026 return resultobj;
43027 fail:
43028 return NULL;
43029 }
43030
43031
43032 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43033 PyObject *resultobj = 0;
43034 wxMenu *arg1 = (wxMenu *) 0 ;
43035 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43036 wxMenuItem *result = 0 ;
43037 void *argp1 = 0 ;
43038 int res1 = 0 ;
43039 void *argp2 = 0 ;
43040 int res2 = 0 ;
43041 PyObject * obj0 = 0 ;
43042 PyObject * obj1 = 0 ;
43043 char * kwnames[] = {
43044 (char *) "self",(char *) "item", NULL
43045 };
43046
43047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43049 if (!SWIG_IsOK(res1)) {
43050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43051 }
43052 arg1 = reinterpret_cast< wxMenu * >(argp1);
43053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43054 if (!SWIG_IsOK(res2)) {
43055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43056 }
43057 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43058 {
43059 PyThreadState* __tstate = wxPyBeginAllowThreads();
43060 result = (wxMenuItem *)(arg1)->Remove(arg2);
43061 wxPyEndAllowThreads(__tstate);
43062 if (PyErr_Occurred()) SWIG_fail;
43063 }
43064 {
43065 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43066 }
43067 return resultobj;
43068 fail:
43069 return NULL;
43070 }
43071
43072
43073 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43074 PyObject *resultobj = 0;
43075 wxMenu *arg1 = (wxMenu *) 0 ;
43076 int arg2 ;
43077 bool result;
43078 void *argp1 = 0 ;
43079 int res1 = 0 ;
43080 int val2 ;
43081 int ecode2 = 0 ;
43082 PyObject * obj0 = 0 ;
43083 PyObject * obj1 = 0 ;
43084 char * kwnames[] = {
43085 (char *) "self",(char *) "id", NULL
43086 };
43087
43088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43090 if (!SWIG_IsOK(res1)) {
43091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43092 }
43093 arg1 = reinterpret_cast< wxMenu * >(argp1);
43094 ecode2 = SWIG_AsVal_int(obj1, &val2);
43095 if (!SWIG_IsOK(ecode2)) {
43096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43097 }
43098 arg2 = static_cast< int >(val2);
43099 {
43100 PyThreadState* __tstate = wxPyBeginAllowThreads();
43101 result = (bool)(arg1)->Delete(arg2);
43102 wxPyEndAllowThreads(__tstate);
43103 if (PyErr_Occurred()) SWIG_fail;
43104 }
43105 {
43106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43107 }
43108 return resultobj;
43109 fail:
43110 return NULL;
43111 }
43112
43113
43114 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43115 PyObject *resultobj = 0;
43116 wxMenu *arg1 = (wxMenu *) 0 ;
43117 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43118 bool result;
43119 void *argp1 = 0 ;
43120 int res1 = 0 ;
43121 void *argp2 = 0 ;
43122 int res2 = 0 ;
43123 PyObject * obj0 = 0 ;
43124 PyObject * obj1 = 0 ;
43125 char * kwnames[] = {
43126 (char *) "self",(char *) "item", NULL
43127 };
43128
43129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43131 if (!SWIG_IsOK(res1)) {
43132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43133 }
43134 arg1 = reinterpret_cast< wxMenu * >(argp1);
43135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43136 if (!SWIG_IsOK(res2)) {
43137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43138 }
43139 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43140 {
43141 PyThreadState* __tstate = wxPyBeginAllowThreads();
43142 result = (bool)(arg1)->Delete(arg2);
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 {
43147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43148 }
43149 return resultobj;
43150 fail:
43151 return NULL;
43152 }
43153
43154
43155 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43156 PyObject *resultobj = 0;
43157 wxMenu *arg1 = (wxMenu *) 0 ;
43158 void *argp1 = 0 ;
43159 int res1 = 0 ;
43160 PyObject *swig_obj[1] ;
43161
43162 if (!args) SWIG_fail;
43163 swig_obj[0] = args;
43164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43165 if (!SWIG_IsOK(res1)) {
43166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43167 }
43168 arg1 = reinterpret_cast< wxMenu * >(argp1);
43169 {
43170 PyThreadState* __tstate = wxPyBeginAllowThreads();
43171 wxMenu_Destroy(arg1);
43172 wxPyEndAllowThreads(__tstate);
43173 if (PyErr_Occurred()) SWIG_fail;
43174 }
43175 resultobj = SWIG_Py_Void();
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43183 PyObject *resultobj = 0;
43184 wxMenu *arg1 = (wxMenu *) 0 ;
43185 int arg2 ;
43186 bool result;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 int val2 ;
43190 int ecode2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "id", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenu * >(argp1);
43203 ecode2 = SWIG_AsVal_int(obj1, &val2);
43204 if (!SWIG_IsOK(ecode2)) {
43205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43206 }
43207 arg2 = static_cast< int >(val2);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = (bool)(arg1)->Destroy(arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 {
43215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43216 }
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43224 PyObject *resultobj = 0;
43225 wxMenu *arg1 = (wxMenu *) 0 ;
43226 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43227 bool result;
43228 void *argp1 = 0 ;
43229 int res1 = 0 ;
43230 void *argp2 = 0 ;
43231 int res2 = 0 ;
43232 PyObject * obj0 = 0 ;
43233 PyObject * obj1 = 0 ;
43234 char * kwnames[] = {
43235 (char *) "self",(char *) "item", NULL
43236 };
43237
43238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43240 if (!SWIG_IsOK(res1)) {
43241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43242 }
43243 arg1 = reinterpret_cast< wxMenu * >(argp1);
43244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43245 if (!SWIG_IsOK(res2)) {
43246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43247 }
43248 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43249 {
43250 PyThreadState* __tstate = wxPyBeginAllowThreads();
43251 result = (bool)(arg1)->Destroy(arg2);
43252 wxPyEndAllowThreads(__tstate);
43253 if (PyErr_Occurred()) SWIG_fail;
43254 }
43255 {
43256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43257 }
43258 return resultobj;
43259 fail:
43260 return NULL;
43261 }
43262
43263
43264 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43265 PyObject *resultobj = 0;
43266 wxMenu *arg1 = (wxMenu *) 0 ;
43267 size_t result;
43268 void *argp1 = 0 ;
43269 int res1 = 0 ;
43270 PyObject *swig_obj[1] ;
43271
43272 if (!args) SWIG_fail;
43273 swig_obj[0] = args;
43274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43275 if (!SWIG_IsOK(res1)) {
43276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43277 }
43278 arg1 = reinterpret_cast< wxMenu * >(argp1);
43279 {
43280 PyThreadState* __tstate = wxPyBeginAllowThreads();
43281 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43282 wxPyEndAllowThreads(__tstate);
43283 if (PyErr_Occurred()) SWIG_fail;
43284 }
43285 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43286 return resultobj;
43287 fail:
43288 return NULL;
43289 }
43290
43291
43292 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43293 PyObject *resultobj = 0;
43294 wxMenu *arg1 = (wxMenu *) 0 ;
43295 PyObject *result = 0 ;
43296 void *argp1 = 0 ;
43297 int res1 = 0 ;
43298 PyObject *swig_obj[1] ;
43299
43300 if (!args) SWIG_fail;
43301 swig_obj[0] = args;
43302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43303 if (!SWIG_IsOK(res1)) {
43304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43305 }
43306 arg1 = reinterpret_cast< wxMenu * >(argp1);
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 resultobj = result;
43314 return resultobj;
43315 fail:
43316 return NULL;
43317 }
43318
43319
43320 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43321 PyObject *resultobj = 0;
43322 wxMenu *arg1 = (wxMenu *) 0 ;
43323 wxString *arg2 = 0 ;
43324 int result;
43325 void *argp1 = 0 ;
43326 int res1 = 0 ;
43327 bool temp2 = false ;
43328 PyObject * obj0 = 0 ;
43329 PyObject * obj1 = 0 ;
43330 char * kwnames[] = {
43331 (char *) "self",(char *) "item", NULL
43332 };
43333
43334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43336 if (!SWIG_IsOK(res1)) {
43337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43338 }
43339 arg1 = reinterpret_cast< wxMenu * >(argp1);
43340 {
43341 arg2 = wxString_in_helper(obj1);
43342 if (arg2 == NULL) SWIG_fail;
43343 temp2 = true;
43344 }
43345 {
43346 PyThreadState* __tstate = wxPyBeginAllowThreads();
43347 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43348 wxPyEndAllowThreads(__tstate);
43349 if (PyErr_Occurred()) SWIG_fail;
43350 }
43351 resultobj = SWIG_From_int(static_cast< int >(result));
43352 {
43353 if (temp2)
43354 delete arg2;
43355 }
43356 return resultobj;
43357 fail:
43358 {
43359 if (temp2)
43360 delete arg2;
43361 }
43362 return NULL;
43363 }
43364
43365
43366 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43367 PyObject *resultobj = 0;
43368 wxMenu *arg1 = (wxMenu *) 0 ;
43369 int arg2 ;
43370 wxMenuItem *result = 0 ;
43371 void *argp1 = 0 ;
43372 int res1 = 0 ;
43373 int val2 ;
43374 int ecode2 = 0 ;
43375 PyObject * obj0 = 0 ;
43376 PyObject * obj1 = 0 ;
43377 char * kwnames[] = {
43378 (char *) "self",(char *) "id", NULL
43379 };
43380
43381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43383 if (!SWIG_IsOK(res1)) {
43384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43385 }
43386 arg1 = reinterpret_cast< wxMenu * >(argp1);
43387 ecode2 = SWIG_AsVal_int(obj1, &val2);
43388 if (!SWIG_IsOK(ecode2)) {
43389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43390 }
43391 arg2 = static_cast< int >(val2);
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43395 wxPyEndAllowThreads(__tstate);
43396 if (PyErr_Occurred()) SWIG_fail;
43397 }
43398 {
43399 resultobj = wxPyMake_wxObject(result, (bool)0);
43400 }
43401 return resultobj;
43402 fail:
43403 return NULL;
43404 }
43405
43406
43407 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43408 PyObject *resultobj = 0;
43409 wxMenu *arg1 = (wxMenu *) 0 ;
43410 size_t arg2 ;
43411 wxMenuItem *result = 0 ;
43412 void *argp1 = 0 ;
43413 int res1 = 0 ;
43414 size_t val2 ;
43415 int ecode2 = 0 ;
43416 PyObject * obj0 = 0 ;
43417 PyObject * obj1 = 0 ;
43418 char * kwnames[] = {
43419 (char *) "self",(char *) "position", NULL
43420 };
43421
43422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43424 if (!SWIG_IsOK(res1)) {
43425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43426 }
43427 arg1 = reinterpret_cast< wxMenu * >(argp1);
43428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43429 if (!SWIG_IsOK(ecode2)) {
43430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43431 }
43432 arg2 = static_cast< size_t >(val2);
43433 {
43434 PyThreadState* __tstate = wxPyBeginAllowThreads();
43435 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43436 wxPyEndAllowThreads(__tstate);
43437 if (PyErr_Occurred()) SWIG_fail;
43438 }
43439 {
43440 resultobj = wxPyMake_wxObject(result, (bool)0);
43441 }
43442 return resultobj;
43443 fail:
43444 return NULL;
43445 }
43446
43447
43448 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43449 PyObject *resultobj = 0;
43450 wxMenu *arg1 = (wxMenu *) 0 ;
43451 int arg2 ;
43452 bool arg3 ;
43453 void *argp1 = 0 ;
43454 int res1 = 0 ;
43455 int val2 ;
43456 int ecode2 = 0 ;
43457 bool val3 ;
43458 int ecode3 = 0 ;
43459 PyObject * obj0 = 0 ;
43460 PyObject * obj1 = 0 ;
43461 PyObject * obj2 = 0 ;
43462 char * kwnames[] = {
43463 (char *) "self",(char *) "id",(char *) "enable", NULL
43464 };
43465
43466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43468 if (!SWIG_IsOK(res1)) {
43469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43470 }
43471 arg1 = reinterpret_cast< wxMenu * >(argp1);
43472 ecode2 = SWIG_AsVal_int(obj1, &val2);
43473 if (!SWIG_IsOK(ecode2)) {
43474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43475 }
43476 arg2 = static_cast< int >(val2);
43477 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43478 if (!SWIG_IsOK(ecode3)) {
43479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43480 }
43481 arg3 = static_cast< bool >(val3);
43482 {
43483 PyThreadState* __tstate = wxPyBeginAllowThreads();
43484 (arg1)->Enable(arg2,arg3);
43485 wxPyEndAllowThreads(__tstate);
43486 if (PyErr_Occurred()) SWIG_fail;
43487 }
43488 resultobj = SWIG_Py_Void();
43489 return resultobj;
43490 fail:
43491 return NULL;
43492 }
43493
43494
43495 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43496 PyObject *resultobj = 0;
43497 wxMenu *arg1 = (wxMenu *) 0 ;
43498 int arg2 ;
43499 bool result;
43500 void *argp1 = 0 ;
43501 int res1 = 0 ;
43502 int val2 ;
43503 int ecode2 = 0 ;
43504 PyObject * obj0 = 0 ;
43505 PyObject * obj1 = 0 ;
43506 char * kwnames[] = {
43507 (char *) "self",(char *) "id", NULL
43508 };
43509
43510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43512 if (!SWIG_IsOK(res1)) {
43513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43514 }
43515 arg1 = reinterpret_cast< wxMenu * >(argp1);
43516 ecode2 = SWIG_AsVal_int(obj1, &val2);
43517 if (!SWIG_IsOK(ecode2)) {
43518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43519 }
43520 arg2 = static_cast< int >(val2);
43521 {
43522 PyThreadState* __tstate = wxPyBeginAllowThreads();
43523 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43524 wxPyEndAllowThreads(__tstate);
43525 if (PyErr_Occurred()) SWIG_fail;
43526 }
43527 {
43528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43529 }
43530 return resultobj;
43531 fail:
43532 return NULL;
43533 }
43534
43535
43536 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43537 PyObject *resultobj = 0;
43538 wxMenu *arg1 = (wxMenu *) 0 ;
43539 int arg2 ;
43540 bool arg3 ;
43541 void *argp1 = 0 ;
43542 int res1 = 0 ;
43543 int val2 ;
43544 int ecode2 = 0 ;
43545 bool val3 ;
43546 int ecode3 = 0 ;
43547 PyObject * obj0 = 0 ;
43548 PyObject * obj1 = 0 ;
43549 PyObject * obj2 = 0 ;
43550 char * kwnames[] = {
43551 (char *) "self",(char *) "id",(char *) "check", NULL
43552 };
43553
43554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43556 if (!SWIG_IsOK(res1)) {
43557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43558 }
43559 arg1 = reinterpret_cast< wxMenu * >(argp1);
43560 ecode2 = SWIG_AsVal_int(obj1, &val2);
43561 if (!SWIG_IsOK(ecode2)) {
43562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43563 }
43564 arg2 = static_cast< int >(val2);
43565 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43566 if (!SWIG_IsOK(ecode3)) {
43567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43568 }
43569 arg3 = static_cast< bool >(val3);
43570 {
43571 PyThreadState* __tstate = wxPyBeginAllowThreads();
43572 (arg1)->Check(arg2,arg3);
43573 wxPyEndAllowThreads(__tstate);
43574 if (PyErr_Occurred()) SWIG_fail;
43575 }
43576 resultobj = SWIG_Py_Void();
43577 return resultobj;
43578 fail:
43579 return NULL;
43580 }
43581
43582
43583 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43584 PyObject *resultobj = 0;
43585 wxMenu *arg1 = (wxMenu *) 0 ;
43586 int arg2 ;
43587 bool result;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 int val2 ;
43591 int ecode2 = 0 ;
43592 PyObject * obj0 = 0 ;
43593 PyObject * obj1 = 0 ;
43594 char * kwnames[] = {
43595 (char *) "self",(char *) "id", NULL
43596 };
43597
43598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43600 if (!SWIG_IsOK(res1)) {
43601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43602 }
43603 arg1 = reinterpret_cast< wxMenu * >(argp1);
43604 ecode2 = SWIG_AsVal_int(obj1, &val2);
43605 if (!SWIG_IsOK(ecode2)) {
43606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43607 }
43608 arg2 = static_cast< int >(val2);
43609 {
43610 PyThreadState* __tstate = wxPyBeginAllowThreads();
43611 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43612 wxPyEndAllowThreads(__tstate);
43613 if (PyErr_Occurred()) SWIG_fail;
43614 }
43615 {
43616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43617 }
43618 return resultobj;
43619 fail:
43620 return NULL;
43621 }
43622
43623
43624 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43625 PyObject *resultobj = 0;
43626 wxMenu *arg1 = (wxMenu *) 0 ;
43627 int arg2 ;
43628 wxString *arg3 = 0 ;
43629 void *argp1 = 0 ;
43630 int res1 = 0 ;
43631 int val2 ;
43632 int ecode2 = 0 ;
43633 bool temp3 = false ;
43634 PyObject * obj0 = 0 ;
43635 PyObject * obj1 = 0 ;
43636 PyObject * obj2 = 0 ;
43637 char * kwnames[] = {
43638 (char *) "self",(char *) "id",(char *) "label", NULL
43639 };
43640
43641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43643 if (!SWIG_IsOK(res1)) {
43644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43645 }
43646 arg1 = reinterpret_cast< wxMenu * >(argp1);
43647 ecode2 = SWIG_AsVal_int(obj1, &val2);
43648 if (!SWIG_IsOK(ecode2)) {
43649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43650 }
43651 arg2 = static_cast< int >(val2);
43652 {
43653 arg3 = wxString_in_helper(obj2);
43654 if (arg3 == NULL) SWIG_fail;
43655 temp3 = true;
43656 }
43657 {
43658 PyThreadState* __tstate = wxPyBeginAllowThreads();
43659 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43660 wxPyEndAllowThreads(__tstate);
43661 if (PyErr_Occurred()) SWIG_fail;
43662 }
43663 resultobj = SWIG_Py_Void();
43664 {
43665 if (temp3)
43666 delete arg3;
43667 }
43668 return resultobj;
43669 fail:
43670 {
43671 if (temp3)
43672 delete arg3;
43673 }
43674 return NULL;
43675 }
43676
43677
43678 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43679 PyObject *resultobj = 0;
43680 wxMenu *arg1 = (wxMenu *) 0 ;
43681 int arg2 ;
43682 wxString result;
43683 void *argp1 = 0 ;
43684 int res1 = 0 ;
43685 int val2 ;
43686 int ecode2 = 0 ;
43687 PyObject * obj0 = 0 ;
43688 PyObject * obj1 = 0 ;
43689 char * kwnames[] = {
43690 (char *) "self",(char *) "id", NULL
43691 };
43692
43693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenu * >(argp1);
43699 ecode2 = SWIG_AsVal_int(obj1, &val2);
43700 if (!SWIG_IsOK(ecode2)) {
43701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43702 }
43703 arg2 = static_cast< int >(val2);
43704 {
43705 PyThreadState* __tstate = wxPyBeginAllowThreads();
43706 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43707 wxPyEndAllowThreads(__tstate);
43708 if (PyErr_Occurred()) SWIG_fail;
43709 }
43710 {
43711 #if wxUSE_UNICODE
43712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43713 #else
43714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43715 #endif
43716 }
43717 return resultobj;
43718 fail:
43719 return NULL;
43720 }
43721
43722
43723 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43724 PyObject *resultobj = 0;
43725 wxMenu *arg1 = (wxMenu *) 0 ;
43726 int arg2 ;
43727 wxString *arg3 = 0 ;
43728 void *argp1 = 0 ;
43729 int res1 = 0 ;
43730 int val2 ;
43731 int ecode2 = 0 ;
43732 bool temp3 = false ;
43733 PyObject * obj0 = 0 ;
43734 PyObject * obj1 = 0 ;
43735 PyObject * obj2 = 0 ;
43736 char * kwnames[] = {
43737 (char *) "self",(char *) "id",(char *) "helpString", NULL
43738 };
43739
43740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43742 if (!SWIG_IsOK(res1)) {
43743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43744 }
43745 arg1 = reinterpret_cast< wxMenu * >(argp1);
43746 ecode2 = SWIG_AsVal_int(obj1, &val2);
43747 if (!SWIG_IsOK(ecode2)) {
43748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43749 }
43750 arg2 = static_cast< int >(val2);
43751 {
43752 arg3 = wxString_in_helper(obj2);
43753 if (arg3 == NULL) SWIG_fail;
43754 temp3 = true;
43755 }
43756 {
43757 PyThreadState* __tstate = wxPyBeginAllowThreads();
43758 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43759 wxPyEndAllowThreads(__tstate);
43760 if (PyErr_Occurred()) SWIG_fail;
43761 }
43762 resultobj = SWIG_Py_Void();
43763 {
43764 if (temp3)
43765 delete arg3;
43766 }
43767 return resultobj;
43768 fail:
43769 {
43770 if (temp3)
43771 delete arg3;
43772 }
43773 return NULL;
43774 }
43775
43776
43777 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43778 PyObject *resultobj = 0;
43779 wxMenu *arg1 = (wxMenu *) 0 ;
43780 int arg2 ;
43781 wxString result;
43782 void *argp1 = 0 ;
43783 int res1 = 0 ;
43784 int val2 ;
43785 int ecode2 = 0 ;
43786 PyObject * obj0 = 0 ;
43787 PyObject * obj1 = 0 ;
43788 char * kwnames[] = {
43789 (char *) "self",(char *) "id", NULL
43790 };
43791
43792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43794 if (!SWIG_IsOK(res1)) {
43795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43796 }
43797 arg1 = reinterpret_cast< wxMenu * >(argp1);
43798 ecode2 = SWIG_AsVal_int(obj1, &val2);
43799 if (!SWIG_IsOK(ecode2)) {
43800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43801 }
43802 arg2 = static_cast< int >(val2);
43803 {
43804 PyThreadState* __tstate = wxPyBeginAllowThreads();
43805 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43806 wxPyEndAllowThreads(__tstate);
43807 if (PyErr_Occurred()) SWIG_fail;
43808 }
43809 {
43810 #if wxUSE_UNICODE
43811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43812 #else
43813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43814 #endif
43815 }
43816 return resultobj;
43817 fail:
43818 return NULL;
43819 }
43820
43821
43822 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43823 PyObject *resultobj = 0;
43824 wxMenu *arg1 = (wxMenu *) 0 ;
43825 wxString *arg2 = 0 ;
43826 void *argp1 = 0 ;
43827 int res1 = 0 ;
43828 bool temp2 = false ;
43829 PyObject * obj0 = 0 ;
43830 PyObject * obj1 = 0 ;
43831 char * kwnames[] = {
43832 (char *) "self",(char *) "title", NULL
43833 };
43834
43835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43837 if (!SWIG_IsOK(res1)) {
43838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43839 }
43840 arg1 = reinterpret_cast< wxMenu * >(argp1);
43841 {
43842 arg2 = wxString_in_helper(obj1);
43843 if (arg2 == NULL) SWIG_fail;
43844 temp2 = true;
43845 }
43846 {
43847 PyThreadState* __tstate = wxPyBeginAllowThreads();
43848 (arg1)->SetTitle((wxString const &)*arg2);
43849 wxPyEndAllowThreads(__tstate);
43850 if (PyErr_Occurred()) SWIG_fail;
43851 }
43852 resultobj = SWIG_Py_Void();
43853 {
43854 if (temp2)
43855 delete arg2;
43856 }
43857 return resultobj;
43858 fail:
43859 {
43860 if (temp2)
43861 delete arg2;
43862 }
43863 return NULL;
43864 }
43865
43866
43867 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43868 PyObject *resultobj = 0;
43869 wxMenu *arg1 = (wxMenu *) 0 ;
43870 wxString result;
43871 void *argp1 = 0 ;
43872 int res1 = 0 ;
43873 PyObject *swig_obj[1] ;
43874
43875 if (!args) SWIG_fail;
43876 swig_obj[0] = args;
43877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43878 if (!SWIG_IsOK(res1)) {
43879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43880 }
43881 arg1 = reinterpret_cast< wxMenu * >(argp1);
43882 {
43883 PyThreadState* __tstate = wxPyBeginAllowThreads();
43884 result = ((wxMenu const *)arg1)->GetTitle();
43885 wxPyEndAllowThreads(__tstate);
43886 if (PyErr_Occurred()) SWIG_fail;
43887 }
43888 {
43889 #if wxUSE_UNICODE
43890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43891 #else
43892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43893 #endif
43894 }
43895 return resultobj;
43896 fail:
43897 return NULL;
43898 }
43899
43900
43901 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43902 PyObject *resultobj = 0;
43903 wxMenu *arg1 = (wxMenu *) 0 ;
43904 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43905 void *argp1 = 0 ;
43906 int res1 = 0 ;
43907 void *argp2 = 0 ;
43908 int res2 = 0 ;
43909 PyObject * obj0 = 0 ;
43910 PyObject * obj1 = 0 ;
43911 char * kwnames[] = {
43912 (char *) "self",(char *) "handler", NULL
43913 };
43914
43915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43917 if (!SWIG_IsOK(res1)) {
43918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43919 }
43920 arg1 = reinterpret_cast< wxMenu * >(argp1);
43921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43922 if (!SWIG_IsOK(res2)) {
43923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43924 }
43925 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43926 {
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 (arg1)->SetEventHandler(arg2);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_Py_Void();
43933 return resultobj;
43934 fail:
43935 return NULL;
43936 }
43937
43938
43939 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43940 PyObject *resultobj = 0;
43941 wxMenu *arg1 = (wxMenu *) 0 ;
43942 wxEvtHandler *result = 0 ;
43943 void *argp1 = 0 ;
43944 int res1 = 0 ;
43945 PyObject *swig_obj[1] ;
43946
43947 if (!args) SWIG_fail;
43948 swig_obj[0] = args;
43949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43950 if (!SWIG_IsOK(res1)) {
43951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43952 }
43953 arg1 = reinterpret_cast< wxMenu * >(argp1);
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43957 wxPyEndAllowThreads(__tstate);
43958 if (PyErr_Occurred()) SWIG_fail;
43959 }
43960 {
43961 resultobj = wxPyMake_wxObject(result, 0);
43962 }
43963 return resultobj;
43964 fail:
43965 return NULL;
43966 }
43967
43968
43969 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43970 PyObject *resultobj = 0;
43971 wxMenu *arg1 = (wxMenu *) 0 ;
43972 wxWindow *arg2 = (wxWindow *) 0 ;
43973 void *argp1 = 0 ;
43974 int res1 = 0 ;
43975 void *argp2 = 0 ;
43976 int res2 = 0 ;
43977 PyObject * obj0 = 0 ;
43978 PyObject * obj1 = 0 ;
43979 char * kwnames[] = {
43980 (char *) "self",(char *) "win", NULL
43981 };
43982
43983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
43984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43985 if (!SWIG_IsOK(res1)) {
43986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
43987 }
43988 arg1 = reinterpret_cast< wxMenu * >(argp1);
43989 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43990 if (!SWIG_IsOK(res2)) {
43991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
43992 }
43993 arg2 = reinterpret_cast< wxWindow * >(argp2);
43994 {
43995 PyThreadState* __tstate = wxPyBeginAllowThreads();
43996 (arg1)->SetInvokingWindow(arg2);
43997 wxPyEndAllowThreads(__tstate);
43998 if (PyErr_Occurred()) SWIG_fail;
43999 }
44000 resultobj = SWIG_Py_Void();
44001 return resultobj;
44002 fail:
44003 return NULL;
44004 }
44005
44006
44007 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44008 PyObject *resultobj = 0;
44009 wxMenu *arg1 = (wxMenu *) 0 ;
44010 wxWindow *result = 0 ;
44011 void *argp1 = 0 ;
44012 int res1 = 0 ;
44013 PyObject *swig_obj[1] ;
44014
44015 if (!args) SWIG_fail;
44016 swig_obj[0] = args;
44017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44018 if (!SWIG_IsOK(res1)) {
44019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44020 }
44021 arg1 = reinterpret_cast< wxMenu * >(argp1);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 {
44029 resultobj = wxPyMake_wxObject(result, 0);
44030 }
44031 return resultobj;
44032 fail:
44033 return NULL;
44034 }
44035
44036
44037 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44038 PyObject *resultobj = 0;
44039 wxMenu *arg1 = (wxMenu *) 0 ;
44040 long result;
44041 void *argp1 = 0 ;
44042 int res1 = 0 ;
44043 PyObject *swig_obj[1] ;
44044
44045 if (!args) SWIG_fail;
44046 swig_obj[0] = args;
44047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44048 if (!SWIG_IsOK(res1)) {
44049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44050 }
44051 arg1 = reinterpret_cast< wxMenu * >(argp1);
44052 {
44053 PyThreadState* __tstate = wxPyBeginAllowThreads();
44054 result = (long)((wxMenu const *)arg1)->GetStyle();
44055 wxPyEndAllowThreads(__tstate);
44056 if (PyErr_Occurred()) SWIG_fail;
44057 }
44058 resultobj = SWIG_From_long(static_cast< long >(result));
44059 return resultobj;
44060 fail:
44061 return NULL;
44062 }
44063
44064
44065 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44066 PyObject *resultobj = 0;
44067 wxMenu *arg1 = (wxMenu *) 0 ;
44068 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44069 void *argp1 = 0 ;
44070 int res1 = 0 ;
44071 void *argp2 = 0 ;
44072 int res2 = 0 ;
44073 PyObject * obj0 = 0 ;
44074 PyObject * obj1 = 0 ;
44075 char * kwnames[] = {
44076 (char *) "self",(char *) "source", NULL
44077 };
44078
44079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44081 if (!SWIG_IsOK(res1)) {
44082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44083 }
44084 arg1 = reinterpret_cast< wxMenu * >(argp1);
44085 if (obj1) {
44086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44087 if (!SWIG_IsOK(res2)) {
44088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44089 }
44090 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44091 }
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 (arg1)->UpdateUI(arg2);
44095 wxPyEndAllowThreads(__tstate);
44096 if (PyErr_Occurred()) SWIG_fail;
44097 }
44098 resultobj = SWIG_Py_Void();
44099 return resultobj;
44100 fail:
44101 return NULL;
44102 }
44103
44104
44105 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44106 PyObject *resultobj = 0;
44107 wxMenu *arg1 = (wxMenu *) 0 ;
44108 wxMenuBar *result = 0 ;
44109 void *argp1 = 0 ;
44110 int res1 = 0 ;
44111 PyObject *swig_obj[1] ;
44112
44113 if (!args) SWIG_fail;
44114 swig_obj[0] = args;
44115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44116 if (!SWIG_IsOK(res1)) {
44117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44118 }
44119 arg1 = reinterpret_cast< wxMenu * >(argp1);
44120 {
44121 PyThreadState* __tstate = wxPyBeginAllowThreads();
44122 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44123 wxPyEndAllowThreads(__tstate);
44124 if (PyErr_Occurred()) SWIG_fail;
44125 }
44126 {
44127 resultobj = wxPyMake_wxObject(result, (bool)0);
44128 }
44129 return resultobj;
44130 fail:
44131 return NULL;
44132 }
44133
44134
44135 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44136 PyObject *resultobj = 0;
44137 wxMenu *arg1 = (wxMenu *) 0 ;
44138 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44139 void *argp1 = 0 ;
44140 int res1 = 0 ;
44141 void *argp2 = 0 ;
44142 int res2 = 0 ;
44143 PyObject * obj0 = 0 ;
44144 PyObject * obj1 = 0 ;
44145 char * kwnames[] = {
44146 (char *) "self",(char *) "menubar", NULL
44147 };
44148
44149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44151 if (!SWIG_IsOK(res1)) {
44152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44153 }
44154 arg1 = reinterpret_cast< wxMenu * >(argp1);
44155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44156 if (!SWIG_IsOK(res2)) {
44157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44158 }
44159 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44160 {
44161 PyThreadState* __tstate = wxPyBeginAllowThreads();
44162 (arg1)->Attach(arg2);
44163 wxPyEndAllowThreads(__tstate);
44164 if (PyErr_Occurred()) SWIG_fail;
44165 }
44166 resultobj = SWIG_Py_Void();
44167 return resultobj;
44168 fail:
44169 return NULL;
44170 }
44171
44172
44173 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44174 PyObject *resultobj = 0;
44175 wxMenu *arg1 = (wxMenu *) 0 ;
44176 void *argp1 = 0 ;
44177 int res1 = 0 ;
44178 PyObject *swig_obj[1] ;
44179
44180 if (!args) SWIG_fail;
44181 swig_obj[0] = args;
44182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44183 if (!SWIG_IsOK(res1)) {
44184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44185 }
44186 arg1 = reinterpret_cast< wxMenu * >(argp1);
44187 {
44188 PyThreadState* __tstate = wxPyBeginAllowThreads();
44189 (arg1)->Detach();
44190 wxPyEndAllowThreads(__tstate);
44191 if (PyErr_Occurred()) SWIG_fail;
44192 }
44193 resultobj = SWIG_Py_Void();
44194 return resultobj;
44195 fail:
44196 return NULL;
44197 }
44198
44199
44200 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44201 PyObject *resultobj = 0;
44202 wxMenu *arg1 = (wxMenu *) 0 ;
44203 bool result;
44204 void *argp1 = 0 ;
44205 int res1 = 0 ;
44206 PyObject *swig_obj[1] ;
44207
44208 if (!args) SWIG_fail;
44209 swig_obj[0] = args;
44210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44211 if (!SWIG_IsOK(res1)) {
44212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44213 }
44214 arg1 = reinterpret_cast< wxMenu * >(argp1);
44215 {
44216 PyThreadState* __tstate = wxPyBeginAllowThreads();
44217 result = (bool)((wxMenu const *)arg1)->IsAttached();
44218 wxPyEndAllowThreads(__tstate);
44219 if (PyErr_Occurred()) SWIG_fail;
44220 }
44221 {
44222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44223 }
44224 return resultobj;
44225 fail:
44226 return NULL;
44227 }
44228
44229
44230 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44231 PyObject *resultobj = 0;
44232 wxMenu *arg1 = (wxMenu *) 0 ;
44233 wxMenu *arg2 = (wxMenu *) 0 ;
44234 void *argp1 = 0 ;
44235 int res1 = 0 ;
44236 void *argp2 = 0 ;
44237 int res2 = 0 ;
44238 PyObject * obj0 = 0 ;
44239 PyObject * obj1 = 0 ;
44240 char * kwnames[] = {
44241 (char *) "self",(char *) "parent", NULL
44242 };
44243
44244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44248 }
44249 arg1 = reinterpret_cast< wxMenu * >(argp1);
44250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44251 if (!SWIG_IsOK(res2)) {
44252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44253 }
44254 arg2 = reinterpret_cast< wxMenu * >(argp2);
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 (arg1)->SetParent(arg2);
44258 wxPyEndAllowThreads(__tstate);
44259 if (PyErr_Occurred()) SWIG_fail;
44260 }
44261 resultobj = SWIG_Py_Void();
44262 return resultobj;
44263 fail:
44264 return NULL;
44265 }
44266
44267
44268 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44269 PyObject *resultobj = 0;
44270 wxMenu *arg1 = (wxMenu *) 0 ;
44271 wxMenu *result = 0 ;
44272 void *argp1 = 0 ;
44273 int res1 = 0 ;
44274 PyObject *swig_obj[1] ;
44275
44276 if (!args) SWIG_fail;
44277 swig_obj[0] = args;
44278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44279 if (!SWIG_IsOK(res1)) {
44280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44281 }
44282 arg1 = reinterpret_cast< wxMenu * >(argp1);
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44286 wxPyEndAllowThreads(__tstate);
44287 if (PyErr_Occurred()) SWIG_fail;
44288 }
44289 {
44290 resultobj = wxPyMake_wxObject(result, 0);
44291 }
44292 return resultobj;
44293 fail:
44294 return NULL;
44295 }
44296
44297
44298 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44299 PyObject *obj;
44300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44301 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44302 return SWIG_Py_Void();
44303 }
44304
44305 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44306 return SWIG_Python_InitShadowInstance(args);
44307 }
44308
44309 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44310 PyObject *resultobj = 0;
44311 long arg1 = (long) 0 ;
44312 wxMenuBar *result = 0 ;
44313 long val1 ;
44314 int ecode1 = 0 ;
44315 PyObject * obj0 = 0 ;
44316 char * kwnames[] = {
44317 (char *) "style", NULL
44318 };
44319
44320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44321 if (obj0) {
44322 ecode1 = SWIG_AsVal_long(obj0, &val1);
44323 if (!SWIG_IsOK(ecode1)) {
44324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44325 }
44326 arg1 = static_cast< long >(val1);
44327 }
44328 {
44329 if (!wxPyCheckForApp()) SWIG_fail;
44330 PyThreadState* __tstate = wxPyBeginAllowThreads();
44331 result = (wxMenuBar *)new wxMenuBar(arg1);
44332 wxPyEndAllowThreads(__tstate);
44333 if (PyErr_Occurred()) SWIG_fail;
44334 }
44335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44336 return resultobj;
44337 fail:
44338 return NULL;
44339 }
44340
44341
44342 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44343 PyObject *resultobj = 0;
44344 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44345 wxMenu *arg2 = (wxMenu *) 0 ;
44346 wxString *arg3 = 0 ;
44347 bool result;
44348 void *argp1 = 0 ;
44349 int res1 = 0 ;
44350 void *argp2 = 0 ;
44351 int res2 = 0 ;
44352 bool temp3 = false ;
44353 PyObject * obj0 = 0 ;
44354 PyObject * obj1 = 0 ;
44355 PyObject * obj2 = 0 ;
44356 char * kwnames[] = {
44357 (char *) "self",(char *) "menu",(char *) "title", NULL
44358 };
44359
44360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44362 if (!SWIG_IsOK(res1)) {
44363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44364 }
44365 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44367 if (!SWIG_IsOK(res2)) {
44368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44369 }
44370 arg2 = reinterpret_cast< wxMenu * >(argp2);
44371 {
44372 arg3 = wxString_in_helper(obj2);
44373 if (arg3 == NULL) SWIG_fail;
44374 temp3 = true;
44375 }
44376 {
44377 PyThreadState* __tstate = wxPyBeginAllowThreads();
44378 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44379 wxPyEndAllowThreads(__tstate);
44380 if (PyErr_Occurred()) SWIG_fail;
44381 }
44382 {
44383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44384 }
44385 {
44386 if (temp3)
44387 delete arg3;
44388 }
44389 return resultobj;
44390 fail:
44391 {
44392 if (temp3)
44393 delete arg3;
44394 }
44395 return NULL;
44396 }
44397
44398
44399 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44400 PyObject *resultobj = 0;
44401 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44402 size_t arg2 ;
44403 wxMenu *arg3 = (wxMenu *) 0 ;
44404 wxString *arg4 = 0 ;
44405 bool result;
44406 void *argp1 = 0 ;
44407 int res1 = 0 ;
44408 size_t val2 ;
44409 int ecode2 = 0 ;
44410 void *argp3 = 0 ;
44411 int res3 = 0 ;
44412 bool temp4 = false ;
44413 PyObject * obj0 = 0 ;
44414 PyObject * obj1 = 0 ;
44415 PyObject * obj2 = 0 ;
44416 PyObject * obj3 = 0 ;
44417 char * kwnames[] = {
44418 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44419 };
44420
44421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44423 if (!SWIG_IsOK(res1)) {
44424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44425 }
44426 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44427 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44428 if (!SWIG_IsOK(ecode2)) {
44429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44430 }
44431 arg2 = static_cast< size_t >(val2);
44432 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44433 if (!SWIG_IsOK(res3)) {
44434 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44435 }
44436 arg3 = reinterpret_cast< wxMenu * >(argp3);
44437 {
44438 arg4 = wxString_in_helper(obj3);
44439 if (arg4 == NULL) SWIG_fail;
44440 temp4 = true;
44441 }
44442 {
44443 PyThreadState* __tstate = wxPyBeginAllowThreads();
44444 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 {
44449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44450 }
44451 {
44452 if (temp4)
44453 delete arg4;
44454 }
44455 return resultobj;
44456 fail:
44457 {
44458 if (temp4)
44459 delete arg4;
44460 }
44461 return NULL;
44462 }
44463
44464
44465 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44466 PyObject *resultobj = 0;
44467 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44468 size_t result;
44469 void *argp1 = 0 ;
44470 int res1 = 0 ;
44471 PyObject *swig_obj[1] ;
44472
44473 if (!args) SWIG_fail;
44474 swig_obj[0] = args;
44475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44476 if (!SWIG_IsOK(res1)) {
44477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44478 }
44479 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44480 {
44481 PyThreadState* __tstate = wxPyBeginAllowThreads();
44482 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44483 wxPyEndAllowThreads(__tstate);
44484 if (PyErr_Occurred()) SWIG_fail;
44485 }
44486 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44487 return resultobj;
44488 fail:
44489 return NULL;
44490 }
44491
44492
44493 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44494 PyObject *resultobj = 0;
44495 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44496 size_t arg2 ;
44497 wxMenu *result = 0 ;
44498 void *argp1 = 0 ;
44499 int res1 = 0 ;
44500 size_t val2 ;
44501 int ecode2 = 0 ;
44502 PyObject * obj0 = 0 ;
44503 PyObject * obj1 = 0 ;
44504 char * kwnames[] = {
44505 (char *) "self",(char *) "pos", NULL
44506 };
44507
44508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44510 if (!SWIG_IsOK(res1)) {
44511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44512 }
44513 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44514 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44515 if (!SWIG_IsOK(ecode2)) {
44516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44517 }
44518 arg2 = static_cast< size_t >(val2);
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44522 wxPyEndAllowThreads(__tstate);
44523 if (PyErr_Occurred()) SWIG_fail;
44524 }
44525 {
44526 resultobj = wxPyMake_wxObject(result, 0);
44527 }
44528 return resultobj;
44529 fail:
44530 return NULL;
44531 }
44532
44533
44534 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44535 PyObject *resultobj = 0;
44536 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44537 size_t arg2 ;
44538 wxMenu *arg3 = (wxMenu *) 0 ;
44539 wxString *arg4 = 0 ;
44540 wxMenu *result = 0 ;
44541 void *argp1 = 0 ;
44542 int res1 = 0 ;
44543 size_t val2 ;
44544 int ecode2 = 0 ;
44545 void *argp3 = 0 ;
44546 int res3 = 0 ;
44547 bool temp4 = false ;
44548 PyObject * obj0 = 0 ;
44549 PyObject * obj1 = 0 ;
44550 PyObject * obj2 = 0 ;
44551 PyObject * obj3 = 0 ;
44552 char * kwnames[] = {
44553 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44554 };
44555
44556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44558 if (!SWIG_IsOK(res1)) {
44559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44560 }
44561 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44562 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44563 if (!SWIG_IsOK(ecode2)) {
44564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44565 }
44566 arg2 = static_cast< size_t >(val2);
44567 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44568 if (!SWIG_IsOK(res3)) {
44569 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44570 }
44571 arg3 = reinterpret_cast< wxMenu * >(argp3);
44572 {
44573 arg4 = wxString_in_helper(obj3);
44574 if (arg4 == NULL) SWIG_fail;
44575 temp4 = true;
44576 }
44577 {
44578 PyThreadState* __tstate = wxPyBeginAllowThreads();
44579 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44580 wxPyEndAllowThreads(__tstate);
44581 if (PyErr_Occurred()) SWIG_fail;
44582 }
44583 {
44584 resultobj = wxPyMake_wxObject(result, 0);
44585 }
44586 {
44587 if (temp4)
44588 delete arg4;
44589 }
44590 return resultobj;
44591 fail:
44592 {
44593 if (temp4)
44594 delete arg4;
44595 }
44596 return NULL;
44597 }
44598
44599
44600 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44601 PyObject *resultobj = 0;
44602 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44603 size_t arg2 ;
44604 wxMenu *result = 0 ;
44605 void *argp1 = 0 ;
44606 int res1 = 0 ;
44607 size_t val2 ;
44608 int ecode2 = 0 ;
44609 PyObject * obj0 = 0 ;
44610 PyObject * obj1 = 0 ;
44611 char * kwnames[] = {
44612 (char *) "self",(char *) "pos", NULL
44613 };
44614
44615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44617 if (!SWIG_IsOK(res1)) {
44618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44619 }
44620 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44621 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44622 if (!SWIG_IsOK(ecode2)) {
44623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44624 }
44625 arg2 = static_cast< size_t >(val2);
44626 {
44627 PyThreadState* __tstate = wxPyBeginAllowThreads();
44628 result = (wxMenu *)(arg1)->Remove(arg2);
44629 wxPyEndAllowThreads(__tstate);
44630 if (PyErr_Occurred()) SWIG_fail;
44631 }
44632 {
44633 resultobj = wxPyMake_wxObject(result, 0);
44634 }
44635 return resultobj;
44636 fail:
44637 return NULL;
44638 }
44639
44640
44641 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44642 PyObject *resultobj = 0;
44643 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44644 size_t arg2 ;
44645 bool arg3 ;
44646 void *argp1 = 0 ;
44647 int res1 = 0 ;
44648 size_t val2 ;
44649 int ecode2 = 0 ;
44650 bool val3 ;
44651 int ecode3 = 0 ;
44652 PyObject * obj0 = 0 ;
44653 PyObject * obj1 = 0 ;
44654 PyObject * obj2 = 0 ;
44655 char * kwnames[] = {
44656 (char *) "self",(char *) "pos",(char *) "enable", NULL
44657 };
44658
44659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44661 if (!SWIG_IsOK(res1)) {
44662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44663 }
44664 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44665 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44666 if (!SWIG_IsOK(ecode2)) {
44667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44668 }
44669 arg2 = static_cast< size_t >(val2);
44670 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44671 if (!SWIG_IsOK(ecode3)) {
44672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44673 }
44674 arg3 = static_cast< bool >(val3);
44675 {
44676 PyThreadState* __tstate = wxPyBeginAllowThreads();
44677 (arg1)->EnableTop(arg2,arg3);
44678 wxPyEndAllowThreads(__tstate);
44679 if (PyErr_Occurred()) SWIG_fail;
44680 }
44681 resultobj = SWIG_Py_Void();
44682 return resultobj;
44683 fail:
44684 return NULL;
44685 }
44686
44687
44688 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44689 PyObject *resultobj = 0;
44690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44691 size_t arg2 ;
44692 bool result;
44693 void *argp1 = 0 ;
44694 int res1 = 0 ;
44695 size_t val2 ;
44696 int ecode2 = 0 ;
44697 PyObject * obj0 = 0 ;
44698 PyObject * obj1 = 0 ;
44699 char * kwnames[] = {
44700 (char *) "self",(char *) "pos", NULL
44701 };
44702
44703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44705 if (!SWIG_IsOK(res1)) {
44706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44707 }
44708 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44710 if (!SWIG_IsOK(ecode2)) {
44711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44712 }
44713 arg2 = static_cast< size_t >(val2);
44714 {
44715 PyThreadState* __tstate = wxPyBeginAllowThreads();
44716 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44717 wxPyEndAllowThreads(__tstate);
44718 if (PyErr_Occurred()) SWIG_fail;
44719 }
44720 {
44721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44722 }
44723 return resultobj;
44724 fail:
44725 return NULL;
44726 }
44727
44728
44729 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44730 PyObject *resultobj = 0;
44731 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44732 size_t arg2 ;
44733 wxString *arg3 = 0 ;
44734 void *argp1 = 0 ;
44735 int res1 = 0 ;
44736 size_t val2 ;
44737 int ecode2 = 0 ;
44738 bool temp3 = false ;
44739 PyObject * obj0 = 0 ;
44740 PyObject * obj1 = 0 ;
44741 PyObject * obj2 = 0 ;
44742 char * kwnames[] = {
44743 (char *) "self",(char *) "pos",(char *) "label", NULL
44744 };
44745
44746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44748 if (!SWIG_IsOK(res1)) {
44749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44750 }
44751 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44752 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44753 if (!SWIG_IsOK(ecode2)) {
44754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44755 }
44756 arg2 = static_cast< size_t >(val2);
44757 {
44758 arg3 = wxString_in_helper(obj2);
44759 if (arg3 == NULL) SWIG_fail;
44760 temp3 = true;
44761 }
44762 {
44763 PyThreadState* __tstate = wxPyBeginAllowThreads();
44764 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44765 wxPyEndAllowThreads(__tstate);
44766 if (PyErr_Occurred()) SWIG_fail;
44767 }
44768 resultobj = SWIG_Py_Void();
44769 {
44770 if (temp3)
44771 delete arg3;
44772 }
44773 return resultobj;
44774 fail:
44775 {
44776 if (temp3)
44777 delete arg3;
44778 }
44779 return NULL;
44780 }
44781
44782
44783 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44784 PyObject *resultobj = 0;
44785 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44786 size_t arg2 ;
44787 wxString result;
44788 void *argp1 = 0 ;
44789 int res1 = 0 ;
44790 size_t val2 ;
44791 int ecode2 = 0 ;
44792 PyObject * obj0 = 0 ;
44793 PyObject * obj1 = 0 ;
44794 char * kwnames[] = {
44795 (char *) "self",(char *) "pos", NULL
44796 };
44797
44798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44800 if (!SWIG_IsOK(res1)) {
44801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44802 }
44803 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44804 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44805 if (!SWIG_IsOK(ecode2)) {
44806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44807 }
44808 arg2 = static_cast< size_t >(val2);
44809 {
44810 PyThreadState* __tstate = wxPyBeginAllowThreads();
44811 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44812 wxPyEndAllowThreads(__tstate);
44813 if (PyErr_Occurred()) SWIG_fail;
44814 }
44815 {
44816 #if wxUSE_UNICODE
44817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44818 #else
44819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44820 #endif
44821 }
44822 return resultobj;
44823 fail:
44824 return NULL;
44825 }
44826
44827
44828 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44829 PyObject *resultobj = 0;
44830 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44831 wxString *arg2 = 0 ;
44832 wxString *arg3 = 0 ;
44833 int result;
44834 void *argp1 = 0 ;
44835 int res1 = 0 ;
44836 bool temp2 = false ;
44837 bool temp3 = false ;
44838 PyObject * obj0 = 0 ;
44839 PyObject * obj1 = 0 ;
44840 PyObject * obj2 = 0 ;
44841 char * kwnames[] = {
44842 (char *) "self",(char *) "menu",(char *) "item", NULL
44843 };
44844
44845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44847 if (!SWIG_IsOK(res1)) {
44848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44849 }
44850 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44851 {
44852 arg2 = wxString_in_helper(obj1);
44853 if (arg2 == NULL) SWIG_fail;
44854 temp2 = true;
44855 }
44856 {
44857 arg3 = wxString_in_helper(obj2);
44858 if (arg3 == NULL) SWIG_fail;
44859 temp3 = true;
44860 }
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44864 wxPyEndAllowThreads(__tstate);
44865 if (PyErr_Occurred()) SWIG_fail;
44866 }
44867 resultobj = SWIG_From_int(static_cast< int >(result));
44868 {
44869 if (temp2)
44870 delete arg2;
44871 }
44872 {
44873 if (temp3)
44874 delete arg3;
44875 }
44876 return resultobj;
44877 fail:
44878 {
44879 if (temp2)
44880 delete arg2;
44881 }
44882 {
44883 if (temp3)
44884 delete arg3;
44885 }
44886 return NULL;
44887 }
44888
44889
44890 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44891 PyObject *resultobj = 0;
44892 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44893 int arg2 ;
44894 wxMenuItem *result = 0 ;
44895 void *argp1 = 0 ;
44896 int res1 = 0 ;
44897 int val2 ;
44898 int ecode2 = 0 ;
44899 PyObject * obj0 = 0 ;
44900 PyObject * obj1 = 0 ;
44901 char * kwnames[] = {
44902 (char *) "self",(char *) "id", NULL
44903 };
44904
44905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44907 if (!SWIG_IsOK(res1)) {
44908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44909 }
44910 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44911 ecode2 = SWIG_AsVal_int(obj1, &val2);
44912 if (!SWIG_IsOK(ecode2)) {
44913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44914 }
44915 arg2 = static_cast< int >(val2);
44916 {
44917 PyThreadState* __tstate = wxPyBeginAllowThreads();
44918 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44919 wxPyEndAllowThreads(__tstate);
44920 if (PyErr_Occurred()) SWIG_fail;
44921 }
44922 {
44923 resultobj = wxPyMake_wxObject(result, (bool)0);
44924 }
44925 return resultobj;
44926 fail:
44927 return NULL;
44928 }
44929
44930
44931 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44932 PyObject *resultobj = 0;
44933 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44934 wxString *arg2 = 0 ;
44935 int result;
44936 void *argp1 = 0 ;
44937 int res1 = 0 ;
44938 bool temp2 = false ;
44939 PyObject * obj0 = 0 ;
44940 PyObject * obj1 = 0 ;
44941 char * kwnames[] = {
44942 (char *) "self",(char *) "title", NULL
44943 };
44944
44945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44947 if (!SWIG_IsOK(res1)) {
44948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44949 }
44950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44951 {
44952 arg2 = wxString_in_helper(obj1);
44953 if (arg2 == NULL) SWIG_fail;
44954 temp2 = true;
44955 }
44956 {
44957 PyThreadState* __tstate = wxPyBeginAllowThreads();
44958 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44959 wxPyEndAllowThreads(__tstate);
44960 if (PyErr_Occurred()) SWIG_fail;
44961 }
44962 resultobj = SWIG_From_int(static_cast< int >(result));
44963 {
44964 if (temp2)
44965 delete arg2;
44966 }
44967 return resultobj;
44968 fail:
44969 {
44970 if (temp2)
44971 delete arg2;
44972 }
44973 return NULL;
44974 }
44975
44976
44977 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44978 PyObject *resultobj = 0;
44979 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44980 int arg2 ;
44981 bool arg3 ;
44982 void *argp1 = 0 ;
44983 int res1 = 0 ;
44984 int val2 ;
44985 int ecode2 = 0 ;
44986 bool val3 ;
44987 int ecode3 = 0 ;
44988 PyObject * obj0 = 0 ;
44989 PyObject * obj1 = 0 ;
44990 PyObject * obj2 = 0 ;
44991 char * kwnames[] = {
44992 (char *) "self",(char *) "id",(char *) "enable", NULL
44993 };
44994
44995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44997 if (!SWIG_IsOK(res1)) {
44998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44999 }
45000 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45001 ecode2 = SWIG_AsVal_int(obj1, &val2);
45002 if (!SWIG_IsOK(ecode2)) {
45003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45004 }
45005 arg2 = static_cast< int >(val2);
45006 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45007 if (!SWIG_IsOK(ecode3)) {
45008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45009 }
45010 arg3 = static_cast< bool >(val3);
45011 {
45012 PyThreadState* __tstate = wxPyBeginAllowThreads();
45013 (arg1)->Enable(arg2,arg3);
45014 wxPyEndAllowThreads(__tstate);
45015 if (PyErr_Occurred()) SWIG_fail;
45016 }
45017 resultobj = SWIG_Py_Void();
45018 return resultobj;
45019 fail:
45020 return NULL;
45021 }
45022
45023
45024 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45025 PyObject *resultobj = 0;
45026 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45027 int arg2 ;
45028 bool arg3 ;
45029 void *argp1 = 0 ;
45030 int res1 = 0 ;
45031 int val2 ;
45032 int ecode2 = 0 ;
45033 bool val3 ;
45034 int ecode3 = 0 ;
45035 PyObject * obj0 = 0 ;
45036 PyObject * obj1 = 0 ;
45037 PyObject * obj2 = 0 ;
45038 char * kwnames[] = {
45039 (char *) "self",(char *) "id",(char *) "check", NULL
45040 };
45041
45042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45044 if (!SWIG_IsOK(res1)) {
45045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45046 }
45047 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45048 ecode2 = SWIG_AsVal_int(obj1, &val2);
45049 if (!SWIG_IsOK(ecode2)) {
45050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45051 }
45052 arg2 = static_cast< int >(val2);
45053 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45054 if (!SWIG_IsOK(ecode3)) {
45055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45056 }
45057 arg3 = static_cast< bool >(val3);
45058 {
45059 PyThreadState* __tstate = wxPyBeginAllowThreads();
45060 (arg1)->Check(arg2,arg3);
45061 wxPyEndAllowThreads(__tstate);
45062 if (PyErr_Occurred()) SWIG_fail;
45063 }
45064 resultobj = SWIG_Py_Void();
45065 return resultobj;
45066 fail:
45067 return NULL;
45068 }
45069
45070
45071 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45072 PyObject *resultobj = 0;
45073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45074 int arg2 ;
45075 bool result;
45076 void *argp1 = 0 ;
45077 int res1 = 0 ;
45078 int val2 ;
45079 int ecode2 = 0 ;
45080 PyObject * obj0 = 0 ;
45081 PyObject * obj1 = 0 ;
45082 char * kwnames[] = {
45083 (char *) "self",(char *) "id", NULL
45084 };
45085
45086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45088 if (!SWIG_IsOK(res1)) {
45089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45090 }
45091 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45092 ecode2 = SWIG_AsVal_int(obj1, &val2);
45093 if (!SWIG_IsOK(ecode2)) {
45094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45095 }
45096 arg2 = static_cast< int >(val2);
45097 {
45098 PyThreadState* __tstate = wxPyBeginAllowThreads();
45099 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45100 wxPyEndAllowThreads(__tstate);
45101 if (PyErr_Occurred()) SWIG_fail;
45102 }
45103 {
45104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45105 }
45106 return resultobj;
45107 fail:
45108 return NULL;
45109 }
45110
45111
45112 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45113 PyObject *resultobj = 0;
45114 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45115 int arg2 ;
45116 bool result;
45117 void *argp1 = 0 ;
45118 int res1 = 0 ;
45119 int val2 ;
45120 int ecode2 = 0 ;
45121 PyObject * obj0 = 0 ;
45122 PyObject * obj1 = 0 ;
45123 char * kwnames[] = {
45124 (char *) "self",(char *) "id", NULL
45125 };
45126
45127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45129 if (!SWIG_IsOK(res1)) {
45130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45131 }
45132 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45133 ecode2 = SWIG_AsVal_int(obj1, &val2);
45134 if (!SWIG_IsOK(ecode2)) {
45135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45136 }
45137 arg2 = static_cast< int >(val2);
45138 {
45139 PyThreadState* __tstate = wxPyBeginAllowThreads();
45140 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45141 wxPyEndAllowThreads(__tstate);
45142 if (PyErr_Occurred()) SWIG_fail;
45143 }
45144 {
45145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45146 }
45147 return resultobj;
45148 fail:
45149 return NULL;
45150 }
45151
45152
45153 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45154 PyObject *resultobj = 0;
45155 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45156 int arg2 ;
45157 wxString *arg3 = 0 ;
45158 void *argp1 = 0 ;
45159 int res1 = 0 ;
45160 int val2 ;
45161 int ecode2 = 0 ;
45162 bool temp3 = false ;
45163 PyObject * obj0 = 0 ;
45164 PyObject * obj1 = 0 ;
45165 PyObject * obj2 = 0 ;
45166 char * kwnames[] = {
45167 (char *) "self",(char *) "id",(char *) "label", NULL
45168 };
45169
45170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45172 if (!SWIG_IsOK(res1)) {
45173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45174 }
45175 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45176 ecode2 = SWIG_AsVal_int(obj1, &val2);
45177 if (!SWIG_IsOK(ecode2)) {
45178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45179 }
45180 arg2 = static_cast< int >(val2);
45181 {
45182 arg3 = wxString_in_helper(obj2);
45183 if (arg3 == NULL) SWIG_fail;
45184 temp3 = true;
45185 }
45186 {
45187 PyThreadState* __tstate = wxPyBeginAllowThreads();
45188 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45189 wxPyEndAllowThreads(__tstate);
45190 if (PyErr_Occurred()) SWIG_fail;
45191 }
45192 resultobj = SWIG_Py_Void();
45193 {
45194 if (temp3)
45195 delete arg3;
45196 }
45197 return resultobj;
45198 fail:
45199 {
45200 if (temp3)
45201 delete arg3;
45202 }
45203 return NULL;
45204 }
45205
45206
45207 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45208 PyObject *resultobj = 0;
45209 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45210 int arg2 ;
45211 wxString result;
45212 void *argp1 = 0 ;
45213 int res1 = 0 ;
45214 int val2 ;
45215 int ecode2 = 0 ;
45216 PyObject * obj0 = 0 ;
45217 PyObject * obj1 = 0 ;
45218 char * kwnames[] = {
45219 (char *) "self",(char *) "id", NULL
45220 };
45221
45222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45226 }
45227 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45228 ecode2 = SWIG_AsVal_int(obj1, &val2);
45229 if (!SWIG_IsOK(ecode2)) {
45230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45231 }
45232 arg2 = static_cast< int >(val2);
45233 {
45234 PyThreadState* __tstate = wxPyBeginAllowThreads();
45235 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45236 wxPyEndAllowThreads(__tstate);
45237 if (PyErr_Occurred()) SWIG_fail;
45238 }
45239 {
45240 #if wxUSE_UNICODE
45241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45242 #else
45243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45244 #endif
45245 }
45246 return resultobj;
45247 fail:
45248 return NULL;
45249 }
45250
45251
45252 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45253 PyObject *resultobj = 0;
45254 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45255 int arg2 ;
45256 wxString *arg3 = 0 ;
45257 void *argp1 = 0 ;
45258 int res1 = 0 ;
45259 int val2 ;
45260 int ecode2 = 0 ;
45261 bool temp3 = false ;
45262 PyObject * obj0 = 0 ;
45263 PyObject * obj1 = 0 ;
45264 PyObject * obj2 = 0 ;
45265 char * kwnames[] = {
45266 (char *) "self",(char *) "id",(char *) "helpString", NULL
45267 };
45268
45269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45271 if (!SWIG_IsOK(res1)) {
45272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45273 }
45274 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45275 ecode2 = SWIG_AsVal_int(obj1, &val2);
45276 if (!SWIG_IsOK(ecode2)) {
45277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45278 }
45279 arg2 = static_cast< int >(val2);
45280 {
45281 arg3 = wxString_in_helper(obj2);
45282 if (arg3 == NULL) SWIG_fail;
45283 temp3 = true;
45284 }
45285 {
45286 PyThreadState* __tstate = wxPyBeginAllowThreads();
45287 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45288 wxPyEndAllowThreads(__tstate);
45289 if (PyErr_Occurred()) SWIG_fail;
45290 }
45291 resultobj = SWIG_Py_Void();
45292 {
45293 if (temp3)
45294 delete arg3;
45295 }
45296 return resultobj;
45297 fail:
45298 {
45299 if (temp3)
45300 delete arg3;
45301 }
45302 return NULL;
45303 }
45304
45305
45306 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45307 PyObject *resultobj = 0;
45308 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45309 int arg2 ;
45310 wxString result;
45311 void *argp1 = 0 ;
45312 int res1 = 0 ;
45313 int val2 ;
45314 int ecode2 = 0 ;
45315 PyObject * obj0 = 0 ;
45316 PyObject * obj1 = 0 ;
45317 char * kwnames[] = {
45318 (char *) "self",(char *) "id", NULL
45319 };
45320
45321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45323 if (!SWIG_IsOK(res1)) {
45324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45325 }
45326 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45327 ecode2 = SWIG_AsVal_int(obj1, &val2);
45328 if (!SWIG_IsOK(ecode2)) {
45329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45330 }
45331 arg2 = static_cast< int >(val2);
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45335 wxPyEndAllowThreads(__tstate);
45336 if (PyErr_Occurred()) SWIG_fail;
45337 }
45338 {
45339 #if wxUSE_UNICODE
45340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45341 #else
45342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45343 #endif
45344 }
45345 return resultobj;
45346 fail:
45347 return NULL;
45348 }
45349
45350
45351 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45352 PyObject *resultobj = 0;
45353 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45354 wxFrame *result = 0 ;
45355 void *argp1 = 0 ;
45356 int res1 = 0 ;
45357 PyObject *swig_obj[1] ;
45358
45359 if (!args) SWIG_fail;
45360 swig_obj[0] = args;
45361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45362 if (!SWIG_IsOK(res1)) {
45363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45364 }
45365 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45366 {
45367 PyThreadState* __tstate = wxPyBeginAllowThreads();
45368 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45369 wxPyEndAllowThreads(__tstate);
45370 if (PyErr_Occurred()) SWIG_fail;
45371 }
45372 {
45373 resultobj = wxPyMake_wxObject(result, (bool)0);
45374 }
45375 return resultobj;
45376 fail:
45377 return NULL;
45378 }
45379
45380
45381 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45382 PyObject *resultobj = 0;
45383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45384 bool result;
45385 void *argp1 = 0 ;
45386 int res1 = 0 ;
45387 PyObject *swig_obj[1] ;
45388
45389 if (!args) SWIG_fail;
45390 swig_obj[0] = args;
45391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45392 if (!SWIG_IsOK(res1)) {
45393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45394 }
45395 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45396 {
45397 PyThreadState* __tstate = wxPyBeginAllowThreads();
45398 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45399 wxPyEndAllowThreads(__tstate);
45400 if (PyErr_Occurred()) SWIG_fail;
45401 }
45402 {
45403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45404 }
45405 return resultobj;
45406 fail:
45407 return NULL;
45408 }
45409
45410
45411 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45412 PyObject *resultobj = 0;
45413 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45414 wxFrame *arg2 = (wxFrame *) 0 ;
45415 void *argp1 = 0 ;
45416 int res1 = 0 ;
45417 void *argp2 = 0 ;
45418 int res2 = 0 ;
45419 PyObject * obj0 = 0 ;
45420 PyObject * obj1 = 0 ;
45421 char * kwnames[] = {
45422 (char *) "self",(char *) "frame", NULL
45423 };
45424
45425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45427 if (!SWIG_IsOK(res1)) {
45428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45429 }
45430 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45432 if (!SWIG_IsOK(res2)) {
45433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45434 }
45435 arg2 = reinterpret_cast< wxFrame * >(argp2);
45436 {
45437 PyThreadState* __tstate = wxPyBeginAllowThreads();
45438 (arg1)->Attach(arg2);
45439 wxPyEndAllowThreads(__tstate);
45440 if (PyErr_Occurred()) SWIG_fail;
45441 }
45442 resultobj = SWIG_Py_Void();
45443 return resultobj;
45444 fail:
45445 return NULL;
45446 }
45447
45448
45449 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45450 PyObject *resultobj = 0;
45451 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45452 void *argp1 = 0 ;
45453 int res1 = 0 ;
45454 PyObject *swig_obj[1] ;
45455
45456 if (!args) SWIG_fail;
45457 swig_obj[0] = args;
45458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45459 if (!SWIG_IsOK(res1)) {
45460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45461 }
45462 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45463 {
45464 PyThreadState* __tstate = wxPyBeginAllowThreads();
45465 (arg1)->Detach();
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 resultobj = SWIG_Py_Void();
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45477 PyObject *resultobj = 0;
45478 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45479 void *argp1 = 0 ;
45480 int res1 = 0 ;
45481 PyObject *swig_obj[1] ;
45482
45483 if (!args) SWIG_fail;
45484 swig_obj[0] = args;
45485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45486 if (!SWIG_IsOK(res1)) {
45487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45488 }
45489 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45490 {
45491 PyThreadState* __tstate = wxPyBeginAllowThreads();
45492 (arg1)->UpdateMenus();
45493 wxPyEndAllowThreads(__tstate);
45494 if (PyErr_Occurred()) SWIG_fail;
45495 }
45496 resultobj = SWIG_Py_Void();
45497 return resultobj;
45498 fail:
45499 return NULL;
45500 }
45501
45502
45503 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45504 PyObject *resultobj = 0;
45505 bool arg1 ;
45506 bool val1 ;
45507 int ecode1 = 0 ;
45508 PyObject * obj0 = 0 ;
45509 char * kwnames[] = {
45510 (char *) "enable", NULL
45511 };
45512
45513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45514 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45515 if (!SWIG_IsOK(ecode1)) {
45516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45517 }
45518 arg1 = static_cast< bool >(val1);
45519 {
45520 PyThreadState* __tstate = wxPyBeginAllowThreads();
45521 wxMenuBar::SetAutoWindowMenu(arg1);
45522 wxPyEndAllowThreads(__tstate);
45523 if (PyErr_Occurred()) SWIG_fail;
45524 }
45525 resultobj = SWIG_Py_Void();
45526 return resultobj;
45527 fail:
45528 return NULL;
45529 }
45530
45531
45532 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45533 PyObject *resultobj = 0;
45534 bool result;
45535
45536 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45537 {
45538 PyThreadState* __tstate = wxPyBeginAllowThreads();
45539 result = (bool)wxMenuBar::GetAutoWindowMenu();
45540 wxPyEndAllowThreads(__tstate);
45541 if (PyErr_Occurred()) SWIG_fail;
45542 }
45543 {
45544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45545 }
45546 return resultobj;
45547 fail:
45548 return NULL;
45549 }
45550
45551
45552 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45553 PyObject *obj;
45554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45555 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45556 return SWIG_Py_Void();
45557 }
45558
45559 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45560 return SWIG_Python_InitShadowInstance(args);
45561 }
45562
45563 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45564 PyObject *resultobj = 0;
45565 wxMenu *arg1 = (wxMenu *) NULL ;
45566 int arg2 = (int) wxID_ANY ;
45567 wxString const &arg3_defvalue = wxPyEmptyString ;
45568 wxString *arg3 = (wxString *) &arg3_defvalue ;
45569 wxString const &arg4_defvalue = wxPyEmptyString ;
45570 wxString *arg4 = (wxString *) &arg4_defvalue ;
45571 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45572 wxMenu *arg6 = (wxMenu *) NULL ;
45573 wxMenuItem *result = 0 ;
45574 void *argp1 = 0 ;
45575 int res1 = 0 ;
45576 int val2 ;
45577 int ecode2 = 0 ;
45578 bool temp3 = false ;
45579 bool temp4 = false ;
45580 int val5 ;
45581 int ecode5 = 0 ;
45582 void *argp6 = 0 ;
45583 int res6 = 0 ;
45584 PyObject * obj0 = 0 ;
45585 PyObject * obj1 = 0 ;
45586 PyObject * obj2 = 0 ;
45587 PyObject * obj3 = 0 ;
45588 PyObject * obj4 = 0 ;
45589 PyObject * obj5 = 0 ;
45590 char * kwnames[] = {
45591 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45592 };
45593
45594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45595 if (obj0) {
45596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45597 if (!SWIG_IsOK(res1)) {
45598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45599 }
45600 arg1 = reinterpret_cast< wxMenu * >(argp1);
45601 }
45602 if (obj1) {
45603 ecode2 = SWIG_AsVal_int(obj1, &val2);
45604 if (!SWIG_IsOK(ecode2)) {
45605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45606 }
45607 arg2 = static_cast< int >(val2);
45608 }
45609 if (obj2) {
45610 {
45611 arg3 = wxString_in_helper(obj2);
45612 if (arg3 == NULL) SWIG_fail;
45613 temp3 = true;
45614 }
45615 }
45616 if (obj3) {
45617 {
45618 arg4 = wxString_in_helper(obj3);
45619 if (arg4 == NULL) SWIG_fail;
45620 temp4 = true;
45621 }
45622 }
45623 if (obj4) {
45624 ecode5 = SWIG_AsVal_int(obj4, &val5);
45625 if (!SWIG_IsOK(ecode5)) {
45626 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45627 }
45628 arg5 = static_cast< wxItemKind >(val5);
45629 }
45630 if (obj5) {
45631 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45632 if (!SWIG_IsOK(res6)) {
45633 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45634 }
45635 arg6 = reinterpret_cast< wxMenu * >(argp6);
45636 }
45637 {
45638 PyThreadState* __tstate = wxPyBeginAllowThreads();
45639 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45640 wxPyEndAllowThreads(__tstate);
45641 if (PyErr_Occurred()) SWIG_fail;
45642 }
45643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45644 {
45645 if (temp3)
45646 delete arg3;
45647 }
45648 {
45649 if (temp4)
45650 delete arg4;
45651 }
45652 return resultobj;
45653 fail:
45654 {
45655 if (temp3)
45656 delete arg3;
45657 }
45658 {
45659 if (temp4)
45660 delete arg4;
45661 }
45662 return NULL;
45663 }
45664
45665
45666 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45667 PyObject *resultobj = 0;
45668 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45669 void *argp1 = 0 ;
45670 int res1 = 0 ;
45671 PyObject *swig_obj[1] ;
45672
45673 if (!args) SWIG_fail;
45674 swig_obj[0] = args;
45675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45678 }
45679 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45680 {
45681 PyThreadState* __tstate = wxPyBeginAllowThreads();
45682 delete arg1;
45683
45684 wxPyEndAllowThreads(__tstate);
45685 if (PyErr_Occurred()) SWIG_fail;
45686 }
45687 resultobj = SWIG_Py_Void();
45688 return resultobj;
45689 fail:
45690 return NULL;
45691 }
45692
45693
45694 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45695 PyObject *resultobj = 0;
45696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45697 wxMenu *result = 0 ;
45698 void *argp1 = 0 ;
45699 int res1 = 0 ;
45700 PyObject *swig_obj[1] ;
45701
45702 if (!args) SWIG_fail;
45703 swig_obj[0] = args;
45704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45705 if (!SWIG_IsOK(res1)) {
45706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45707 }
45708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45709 {
45710 PyThreadState* __tstate = wxPyBeginAllowThreads();
45711 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45712 wxPyEndAllowThreads(__tstate);
45713 if (PyErr_Occurred()) SWIG_fail;
45714 }
45715 {
45716 resultobj = wxPyMake_wxObject(result, 0);
45717 }
45718 return resultobj;
45719 fail:
45720 return NULL;
45721 }
45722
45723
45724 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45725 PyObject *resultobj = 0;
45726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45727 wxMenu *arg2 = (wxMenu *) 0 ;
45728 void *argp1 = 0 ;
45729 int res1 = 0 ;
45730 void *argp2 = 0 ;
45731 int res2 = 0 ;
45732 PyObject * obj0 = 0 ;
45733 PyObject * obj1 = 0 ;
45734 char * kwnames[] = {
45735 (char *) "self",(char *) "menu", NULL
45736 };
45737
45738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45740 if (!SWIG_IsOK(res1)) {
45741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45742 }
45743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45745 if (!SWIG_IsOK(res2)) {
45746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45747 }
45748 arg2 = reinterpret_cast< wxMenu * >(argp2);
45749 {
45750 PyThreadState* __tstate = wxPyBeginAllowThreads();
45751 (arg1)->SetMenu(arg2);
45752 wxPyEndAllowThreads(__tstate);
45753 if (PyErr_Occurred()) SWIG_fail;
45754 }
45755 resultobj = SWIG_Py_Void();
45756 return resultobj;
45757 fail:
45758 return NULL;
45759 }
45760
45761
45762 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45763 PyObject *resultobj = 0;
45764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45765 int arg2 ;
45766 void *argp1 = 0 ;
45767 int res1 = 0 ;
45768 int val2 ;
45769 int ecode2 = 0 ;
45770 PyObject * obj0 = 0 ;
45771 PyObject * obj1 = 0 ;
45772 char * kwnames[] = {
45773 (char *) "self",(char *) "id", NULL
45774 };
45775
45776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45778 if (!SWIG_IsOK(res1)) {
45779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45780 }
45781 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45782 ecode2 = SWIG_AsVal_int(obj1, &val2);
45783 if (!SWIG_IsOK(ecode2)) {
45784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45785 }
45786 arg2 = static_cast< int >(val2);
45787 {
45788 PyThreadState* __tstate = wxPyBeginAllowThreads();
45789 (arg1)->SetId(arg2);
45790 wxPyEndAllowThreads(__tstate);
45791 if (PyErr_Occurred()) SWIG_fail;
45792 }
45793 resultobj = SWIG_Py_Void();
45794 return resultobj;
45795 fail:
45796 return NULL;
45797 }
45798
45799
45800 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45801 PyObject *resultobj = 0;
45802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45803 int result;
45804 void *argp1 = 0 ;
45805 int res1 = 0 ;
45806 PyObject *swig_obj[1] ;
45807
45808 if (!args) SWIG_fail;
45809 swig_obj[0] = args;
45810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45811 if (!SWIG_IsOK(res1)) {
45812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45813 }
45814 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45815 {
45816 PyThreadState* __tstate = wxPyBeginAllowThreads();
45817 result = (int)((wxMenuItem const *)arg1)->GetId();
45818 wxPyEndAllowThreads(__tstate);
45819 if (PyErr_Occurred()) SWIG_fail;
45820 }
45821 resultobj = SWIG_From_int(static_cast< int >(result));
45822 return resultobj;
45823 fail:
45824 return NULL;
45825 }
45826
45827
45828 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45829 PyObject *resultobj = 0;
45830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45831 bool result;
45832 void *argp1 = 0 ;
45833 int res1 = 0 ;
45834 PyObject *swig_obj[1] ;
45835
45836 if (!args) SWIG_fail;
45837 swig_obj[0] = args;
45838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45839 if (!SWIG_IsOK(res1)) {
45840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45841 }
45842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45846 wxPyEndAllowThreads(__tstate);
45847 if (PyErr_Occurred()) SWIG_fail;
45848 }
45849 {
45850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45851 }
45852 return resultobj;
45853 fail:
45854 return NULL;
45855 }
45856
45857
45858 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45859 PyObject *resultobj = 0;
45860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45861 wxString *arg2 = 0 ;
45862 void *argp1 = 0 ;
45863 int res1 = 0 ;
45864 bool temp2 = false ;
45865 PyObject * obj0 = 0 ;
45866 PyObject * obj1 = 0 ;
45867 char * kwnames[] = {
45868 (char *) "self",(char *) "str", NULL
45869 };
45870
45871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45873 if (!SWIG_IsOK(res1)) {
45874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45875 }
45876 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45877 {
45878 arg2 = wxString_in_helper(obj1);
45879 if (arg2 == NULL) SWIG_fail;
45880 temp2 = true;
45881 }
45882 {
45883 PyThreadState* __tstate = wxPyBeginAllowThreads();
45884 (arg1)->SetText((wxString const &)*arg2);
45885 wxPyEndAllowThreads(__tstate);
45886 if (PyErr_Occurred()) SWIG_fail;
45887 }
45888 resultobj = SWIG_Py_Void();
45889 {
45890 if (temp2)
45891 delete arg2;
45892 }
45893 return resultobj;
45894 fail:
45895 {
45896 if (temp2)
45897 delete arg2;
45898 }
45899 return NULL;
45900 }
45901
45902
45903 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45904 PyObject *resultobj = 0;
45905 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45906 wxString result;
45907 void *argp1 = 0 ;
45908 int res1 = 0 ;
45909 PyObject *swig_obj[1] ;
45910
45911 if (!args) SWIG_fail;
45912 swig_obj[0] = args;
45913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45914 if (!SWIG_IsOK(res1)) {
45915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45916 }
45917 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45918 {
45919 PyThreadState* __tstate = wxPyBeginAllowThreads();
45920 result = ((wxMenuItem const *)arg1)->GetLabel();
45921 wxPyEndAllowThreads(__tstate);
45922 if (PyErr_Occurred()) SWIG_fail;
45923 }
45924 {
45925 #if wxUSE_UNICODE
45926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45927 #else
45928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45929 #endif
45930 }
45931 return resultobj;
45932 fail:
45933 return NULL;
45934 }
45935
45936
45937 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45938 PyObject *resultobj = 0;
45939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45940 wxString *result = 0 ;
45941 void *argp1 = 0 ;
45942 int res1 = 0 ;
45943 PyObject *swig_obj[1] ;
45944
45945 if (!args) SWIG_fail;
45946 swig_obj[0] = args;
45947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45948 if (!SWIG_IsOK(res1)) {
45949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45950 }
45951 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45952 {
45953 PyThreadState* __tstate = wxPyBeginAllowThreads();
45954 {
45955 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45956 result = (wxString *) &_result_ref;
45957 }
45958 wxPyEndAllowThreads(__tstate);
45959 if (PyErr_Occurred()) SWIG_fail;
45960 }
45961 {
45962 #if wxUSE_UNICODE
45963 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45964 #else
45965 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45966 #endif
45967 }
45968 return resultobj;
45969 fail:
45970 return NULL;
45971 }
45972
45973
45974 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45975 PyObject *resultobj = 0;
45976 wxString *arg1 = 0 ;
45977 wxString result;
45978 bool temp1 = false ;
45979 PyObject * obj0 = 0 ;
45980 char * kwnames[] = {
45981 (char *) "text", NULL
45982 };
45983
45984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
45985 {
45986 arg1 = wxString_in_helper(obj0);
45987 if (arg1 == NULL) SWIG_fail;
45988 temp1 = true;
45989 }
45990 {
45991 PyThreadState* __tstate = wxPyBeginAllowThreads();
45992 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
45993 wxPyEndAllowThreads(__tstate);
45994 if (PyErr_Occurred()) SWIG_fail;
45995 }
45996 {
45997 #if wxUSE_UNICODE
45998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45999 #else
46000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46001 #endif
46002 }
46003 {
46004 if (temp1)
46005 delete arg1;
46006 }
46007 return resultobj;
46008 fail:
46009 {
46010 if (temp1)
46011 delete arg1;
46012 }
46013 return NULL;
46014 }
46015
46016
46017 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46018 PyObject *resultobj = 0;
46019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46020 wxItemKind result;
46021 void *argp1 = 0 ;
46022 int res1 = 0 ;
46023 PyObject *swig_obj[1] ;
46024
46025 if (!args) SWIG_fail;
46026 swig_obj[0] = args;
46027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46028 if (!SWIG_IsOK(res1)) {
46029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46030 }
46031 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46032 {
46033 PyThreadState* __tstate = wxPyBeginAllowThreads();
46034 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46035 wxPyEndAllowThreads(__tstate);
46036 if (PyErr_Occurred()) SWIG_fail;
46037 }
46038 resultobj = SWIG_From_int(static_cast< int >(result));
46039 return resultobj;
46040 fail:
46041 return NULL;
46042 }
46043
46044
46045 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46046 PyObject *resultobj = 0;
46047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46048 wxItemKind arg2 ;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 int val2 ;
46052 int ecode2 = 0 ;
46053 PyObject * obj0 = 0 ;
46054 PyObject * obj1 = 0 ;
46055 char * kwnames[] = {
46056 (char *) "self",(char *) "kind", NULL
46057 };
46058
46059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46061 if (!SWIG_IsOK(res1)) {
46062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46063 }
46064 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46065 ecode2 = SWIG_AsVal_int(obj1, &val2);
46066 if (!SWIG_IsOK(ecode2)) {
46067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46068 }
46069 arg2 = static_cast< wxItemKind >(val2);
46070 {
46071 PyThreadState* __tstate = wxPyBeginAllowThreads();
46072 (arg1)->SetKind(arg2);
46073 wxPyEndAllowThreads(__tstate);
46074 if (PyErr_Occurred()) SWIG_fail;
46075 }
46076 resultobj = SWIG_Py_Void();
46077 return resultobj;
46078 fail:
46079 return NULL;
46080 }
46081
46082
46083 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46084 PyObject *resultobj = 0;
46085 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46086 bool arg2 ;
46087 void *argp1 = 0 ;
46088 int res1 = 0 ;
46089 bool val2 ;
46090 int ecode2 = 0 ;
46091 PyObject * obj0 = 0 ;
46092 PyObject * obj1 = 0 ;
46093 char * kwnames[] = {
46094 (char *) "self",(char *) "checkable", NULL
46095 };
46096
46097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46099 if (!SWIG_IsOK(res1)) {
46100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46101 }
46102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46103 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46104 if (!SWIG_IsOK(ecode2)) {
46105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46106 }
46107 arg2 = static_cast< bool >(val2);
46108 {
46109 PyThreadState* __tstate = wxPyBeginAllowThreads();
46110 (arg1)->SetCheckable(arg2);
46111 wxPyEndAllowThreads(__tstate);
46112 if (PyErr_Occurred()) SWIG_fail;
46113 }
46114 resultobj = SWIG_Py_Void();
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46122 PyObject *resultobj = 0;
46123 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46124 bool result;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 PyObject *swig_obj[1] ;
46128
46129 if (!args) SWIG_fail;
46130 swig_obj[0] = args;
46131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46134 }
46135 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 {
46143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46144 }
46145 return resultobj;
46146 fail:
46147 return NULL;
46148 }
46149
46150
46151 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46152 PyObject *resultobj = 0;
46153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46154 bool result;
46155 void *argp1 = 0 ;
46156 int res1 = 0 ;
46157 PyObject *swig_obj[1] ;
46158
46159 if (!args) SWIG_fail;
46160 swig_obj[0] = args;
46161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46162 if (!SWIG_IsOK(res1)) {
46163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46164 }
46165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46166 {
46167 PyThreadState* __tstate = wxPyBeginAllowThreads();
46168 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46169 wxPyEndAllowThreads(__tstate);
46170 if (PyErr_Occurred()) SWIG_fail;
46171 }
46172 {
46173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46174 }
46175 return resultobj;
46176 fail:
46177 return NULL;
46178 }
46179
46180
46181 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46182 PyObject *resultobj = 0;
46183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46184 wxMenu *arg2 = (wxMenu *) 0 ;
46185 void *argp1 = 0 ;
46186 int res1 = 0 ;
46187 void *argp2 = 0 ;
46188 int res2 = 0 ;
46189 PyObject * obj0 = 0 ;
46190 PyObject * obj1 = 0 ;
46191 char * kwnames[] = {
46192 (char *) "self",(char *) "menu", NULL
46193 };
46194
46195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46197 if (!SWIG_IsOK(res1)) {
46198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46199 }
46200 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46202 if (!SWIG_IsOK(res2)) {
46203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46204 }
46205 arg2 = reinterpret_cast< wxMenu * >(argp2);
46206 {
46207 PyThreadState* __tstate = wxPyBeginAllowThreads();
46208 (arg1)->SetSubMenu(arg2);
46209 wxPyEndAllowThreads(__tstate);
46210 if (PyErr_Occurred()) SWIG_fail;
46211 }
46212 resultobj = SWIG_Py_Void();
46213 return resultobj;
46214 fail:
46215 return NULL;
46216 }
46217
46218
46219 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46220 PyObject *resultobj = 0;
46221 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46222 wxMenu *result = 0 ;
46223 void *argp1 = 0 ;
46224 int res1 = 0 ;
46225 PyObject *swig_obj[1] ;
46226
46227 if (!args) SWIG_fail;
46228 swig_obj[0] = args;
46229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46230 if (!SWIG_IsOK(res1)) {
46231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46232 }
46233 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 {
46241 resultobj = wxPyMake_wxObject(result, 0);
46242 }
46243 return resultobj;
46244 fail:
46245 return NULL;
46246 }
46247
46248
46249 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46250 PyObject *resultobj = 0;
46251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46252 bool arg2 = (bool) true ;
46253 void *argp1 = 0 ;
46254 int res1 = 0 ;
46255 bool val2 ;
46256 int ecode2 = 0 ;
46257 PyObject * obj0 = 0 ;
46258 PyObject * obj1 = 0 ;
46259 char * kwnames[] = {
46260 (char *) "self",(char *) "enable", NULL
46261 };
46262
46263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46265 if (!SWIG_IsOK(res1)) {
46266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46267 }
46268 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46269 if (obj1) {
46270 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46271 if (!SWIG_IsOK(ecode2)) {
46272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46273 }
46274 arg2 = static_cast< bool >(val2);
46275 }
46276 {
46277 PyThreadState* __tstate = wxPyBeginAllowThreads();
46278 (arg1)->Enable(arg2);
46279 wxPyEndAllowThreads(__tstate);
46280 if (PyErr_Occurred()) SWIG_fail;
46281 }
46282 resultobj = SWIG_Py_Void();
46283 return resultobj;
46284 fail:
46285 return NULL;
46286 }
46287
46288
46289 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46290 PyObject *resultobj = 0;
46291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46292 bool result;
46293 void *argp1 = 0 ;
46294 int res1 = 0 ;
46295 PyObject *swig_obj[1] ;
46296
46297 if (!args) SWIG_fail;
46298 swig_obj[0] = args;
46299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46300 if (!SWIG_IsOK(res1)) {
46301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46302 }
46303 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46304 {
46305 PyThreadState* __tstate = wxPyBeginAllowThreads();
46306 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46307 wxPyEndAllowThreads(__tstate);
46308 if (PyErr_Occurred()) SWIG_fail;
46309 }
46310 {
46311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46312 }
46313 return resultobj;
46314 fail:
46315 return NULL;
46316 }
46317
46318
46319 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46320 PyObject *resultobj = 0;
46321 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46322 bool arg2 = (bool) true ;
46323 void *argp1 = 0 ;
46324 int res1 = 0 ;
46325 bool val2 ;
46326 int ecode2 = 0 ;
46327 PyObject * obj0 = 0 ;
46328 PyObject * obj1 = 0 ;
46329 char * kwnames[] = {
46330 (char *) "self",(char *) "check", NULL
46331 };
46332
46333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46335 if (!SWIG_IsOK(res1)) {
46336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46337 }
46338 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46339 if (obj1) {
46340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46341 if (!SWIG_IsOK(ecode2)) {
46342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46343 }
46344 arg2 = static_cast< bool >(val2);
46345 }
46346 {
46347 PyThreadState* __tstate = wxPyBeginAllowThreads();
46348 (arg1)->Check(arg2);
46349 wxPyEndAllowThreads(__tstate);
46350 if (PyErr_Occurred()) SWIG_fail;
46351 }
46352 resultobj = SWIG_Py_Void();
46353 return resultobj;
46354 fail:
46355 return NULL;
46356 }
46357
46358
46359 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46360 PyObject *resultobj = 0;
46361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46362 bool result;
46363 void *argp1 = 0 ;
46364 int res1 = 0 ;
46365 PyObject *swig_obj[1] ;
46366
46367 if (!args) SWIG_fail;
46368 swig_obj[0] = args;
46369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46370 if (!SWIG_IsOK(res1)) {
46371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46372 }
46373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46374 {
46375 PyThreadState* __tstate = wxPyBeginAllowThreads();
46376 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46377 wxPyEndAllowThreads(__tstate);
46378 if (PyErr_Occurred()) SWIG_fail;
46379 }
46380 {
46381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46382 }
46383 return resultobj;
46384 fail:
46385 return NULL;
46386 }
46387
46388
46389 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46390 PyObject *resultobj = 0;
46391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46392 void *argp1 = 0 ;
46393 int res1 = 0 ;
46394 PyObject *swig_obj[1] ;
46395
46396 if (!args) SWIG_fail;
46397 swig_obj[0] = args;
46398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46399 if (!SWIG_IsOK(res1)) {
46400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46401 }
46402 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46403 {
46404 PyThreadState* __tstate = wxPyBeginAllowThreads();
46405 (arg1)->Toggle();
46406 wxPyEndAllowThreads(__tstate);
46407 if (PyErr_Occurred()) SWIG_fail;
46408 }
46409 resultobj = SWIG_Py_Void();
46410 return resultobj;
46411 fail:
46412 return NULL;
46413 }
46414
46415
46416 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46417 PyObject *resultobj = 0;
46418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46419 wxString *arg2 = 0 ;
46420 void *argp1 = 0 ;
46421 int res1 = 0 ;
46422 bool temp2 = false ;
46423 PyObject * obj0 = 0 ;
46424 PyObject * obj1 = 0 ;
46425 char * kwnames[] = {
46426 (char *) "self",(char *) "str", NULL
46427 };
46428
46429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46431 if (!SWIG_IsOK(res1)) {
46432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46433 }
46434 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46435 {
46436 arg2 = wxString_in_helper(obj1);
46437 if (arg2 == NULL) SWIG_fail;
46438 temp2 = true;
46439 }
46440 {
46441 PyThreadState* __tstate = wxPyBeginAllowThreads();
46442 (arg1)->SetHelp((wxString const &)*arg2);
46443 wxPyEndAllowThreads(__tstate);
46444 if (PyErr_Occurred()) SWIG_fail;
46445 }
46446 resultobj = SWIG_Py_Void();
46447 {
46448 if (temp2)
46449 delete arg2;
46450 }
46451 return resultobj;
46452 fail:
46453 {
46454 if (temp2)
46455 delete arg2;
46456 }
46457 return NULL;
46458 }
46459
46460
46461 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46462 PyObject *resultobj = 0;
46463 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46464 wxString *result = 0 ;
46465 void *argp1 = 0 ;
46466 int res1 = 0 ;
46467 PyObject *swig_obj[1] ;
46468
46469 if (!args) SWIG_fail;
46470 swig_obj[0] = args;
46471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46472 if (!SWIG_IsOK(res1)) {
46473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46474 }
46475 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46476 {
46477 PyThreadState* __tstate = wxPyBeginAllowThreads();
46478 {
46479 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46480 result = (wxString *) &_result_ref;
46481 }
46482 wxPyEndAllowThreads(__tstate);
46483 if (PyErr_Occurred()) SWIG_fail;
46484 }
46485 {
46486 #if wxUSE_UNICODE
46487 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46488 #else
46489 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46490 #endif
46491 }
46492 return resultobj;
46493 fail:
46494 return NULL;
46495 }
46496
46497
46498 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46499 PyObject *resultobj = 0;
46500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46501 wxAcceleratorEntry *result = 0 ;
46502 void *argp1 = 0 ;
46503 int res1 = 0 ;
46504 PyObject *swig_obj[1] ;
46505
46506 if (!args) SWIG_fail;
46507 swig_obj[0] = args;
46508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46509 if (!SWIG_IsOK(res1)) {
46510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46511 }
46512 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46513 {
46514 PyThreadState* __tstate = wxPyBeginAllowThreads();
46515 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46516 wxPyEndAllowThreads(__tstate);
46517 if (PyErr_Occurred()) SWIG_fail;
46518 }
46519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46520 return resultobj;
46521 fail:
46522 return NULL;
46523 }
46524
46525
46526 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46527 PyObject *resultobj = 0;
46528 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46529 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46530 void *argp1 = 0 ;
46531 int res1 = 0 ;
46532 void *argp2 = 0 ;
46533 int res2 = 0 ;
46534 PyObject * obj0 = 0 ;
46535 PyObject * obj1 = 0 ;
46536 char * kwnames[] = {
46537 (char *) "self",(char *) "accel", NULL
46538 };
46539
46540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46542 if (!SWIG_IsOK(res1)) {
46543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46544 }
46545 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46547 if (!SWIG_IsOK(res2)) {
46548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46549 }
46550 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46551 {
46552 PyThreadState* __tstate = wxPyBeginAllowThreads();
46553 (arg1)->SetAccel(arg2);
46554 wxPyEndAllowThreads(__tstate);
46555 if (PyErr_Occurred()) SWIG_fail;
46556 }
46557 resultobj = SWIG_Py_Void();
46558 return resultobj;
46559 fail:
46560 return NULL;
46561 }
46562
46563
46564 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46565 PyObject *resultobj = 0;
46566 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46567 wxBitmap *arg2 = 0 ;
46568 void *argp1 = 0 ;
46569 int res1 = 0 ;
46570 void *argp2 = 0 ;
46571 int res2 = 0 ;
46572 PyObject * obj0 = 0 ;
46573 PyObject * obj1 = 0 ;
46574 char * kwnames[] = {
46575 (char *) "self",(char *) "bitmap", NULL
46576 };
46577
46578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46580 if (!SWIG_IsOK(res1)) {
46581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46582 }
46583 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46584 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46585 if (!SWIG_IsOK(res2)) {
46586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46587 }
46588 if (!argp2) {
46589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46590 }
46591 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46592 {
46593 PyThreadState* __tstate = wxPyBeginAllowThreads();
46594 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46595 wxPyEndAllowThreads(__tstate);
46596 if (PyErr_Occurred()) SWIG_fail;
46597 }
46598 resultobj = SWIG_Py_Void();
46599 return resultobj;
46600 fail:
46601 return NULL;
46602 }
46603
46604
46605 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46606 PyObject *resultobj = 0;
46607 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46608 wxBitmap *result = 0 ;
46609 void *argp1 = 0 ;
46610 int res1 = 0 ;
46611 PyObject *swig_obj[1] ;
46612
46613 if (!args) SWIG_fail;
46614 swig_obj[0] = args;
46615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46616 if (!SWIG_IsOK(res1)) {
46617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46618 }
46619 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46620 {
46621 PyThreadState* __tstate = wxPyBeginAllowThreads();
46622 {
46623 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46624 result = (wxBitmap *) &_result_ref;
46625 }
46626 wxPyEndAllowThreads(__tstate);
46627 if (PyErr_Occurred()) SWIG_fail;
46628 }
46629 {
46630 wxBitmap* resultptr = new wxBitmap(*result);
46631 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46632 }
46633 return resultobj;
46634 fail:
46635 return NULL;
46636 }
46637
46638
46639 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46640 PyObject *resultobj = 0;
46641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46642 wxFont *arg2 = 0 ;
46643 void *argp1 = 0 ;
46644 int res1 = 0 ;
46645 void *argp2 = 0 ;
46646 int res2 = 0 ;
46647 PyObject * obj0 = 0 ;
46648 PyObject * obj1 = 0 ;
46649 char * kwnames[] = {
46650 (char *) "self",(char *) "font", NULL
46651 };
46652
46653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46655 if (!SWIG_IsOK(res1)) {
46656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46657 }
46658 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46659 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46660 if (!SWIG_IsOK(res2)) {
46661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46662 }
46663 if (!argp2) {
46664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46665 }
46666 arg2 = reinterpret_cast< wxFont * >(argp2);
46667 {
46668 PyThreadState* __tstate = wxPyBeginAllowThreads();
46669 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46670 wxPyEndAllowThreads(__tstate);
46671 if (PyErr_Occurred()) SWIG_fail;
46672 }
46673 resultobj = SWIG_Py_Void();
46674 return resultobj;
46675 fail:
46676 return NULL;
46677 }
46678
46679
46680 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46681 PyObject *resultobj = 0;
46682 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46683 wxFont result;
46684 void *argp1 = 0 ;
46685 int res1 = 0 ;
46686 PyObject *swig_obj[1] ;
46687
46688 if (!args) SWIG_fail;
46689 swig_obj[0] = args;
46690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46691 if (!SWIG_IsOK(res1)) {
46692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46693 }
46694 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46695 {
46696 PyThreadState* __tstate = wxPyBeginAllowThreads();
46697 result = wxMenuItem_GetFont(arg1);
46698 wxPyEndAllowThreads(__tstate);
46699 if (PyErr_Occurred()) SWIG_fail;
46700 }
46701 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46702 return resultobj;
46703 fail:
46704 return NULL;
46705 }
46706
46707
46708 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46709 PyObject *resultobj = 0;
46710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46711 wxColour *arg2 = 0 ;
46712 void *argp1 = 0 ;
46713 int res1 = 0 ;
46714 wxColour temp2 ;
46715 PyObject * obj0 = 0 ;
46716 PyObject * obj1 = 0 ;
46717 char * kwnames[] = {
46718 (char *) "self",(char *) "colText", NULL
46719 };
46720
46721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46723 if (!SWIG_IsOK(res1)) {
46724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46725 }
46726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46727 {
46728 arg2 = &temp2;
46729 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46730 }
46731 {
46732 PyThreadState* __tstate = wxPyBeginAllowThreads();
46733 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46734 wxPyEndAllowThreads(__tstate);
46735 if (PyErr_Occurred()) SWIG_fail;
46736 }
46737 resultobj = SWIG_Py_Void();
46738 return resultobj;
46739 fail:
46740 return NULL;
46741 }
46742
46743
46744 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46745 PyObject *resultobj = 0;
46746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46747 wxColour result;
46748 void *argp1 = 0 ;
46749 int res1 = 0 ;
46750 PyObject *swig_obj[1] ;
46751
46752 if (!args) SWIG_fail;
46753 swig_obj[0] = args;
46754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46757 }
46758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46759 {
46760 PyThreadState* __tstate = wxPyBeginAllowThreads();
46761 result = wxMenuItem_GetTextColour(arg1);
46762 wxPyEndAllowThreads(__tstate);
46763 if (PyErr_Occurred()) SWIG_fail;
46764 }
46765 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46766 return resultobj;
46767 fail:
46768 return NULL;
46769 }
46770
46771
46772 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46773 PyObject *resultobj = 0;
46774 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46775 wxColour *arg2 = 0 ;
46776 void *argp1 = 0 ;
46777 int res1 = 0 ;
46778 wxColour temp2 ;
46779 PyObject * obj0 = 0 ;
46780 PyObject * obj1 = 0 ;
46781 char * kwnames[] = {
46782 (char *) "self",(char *) "colBack", NULL
46783 };
46784
46785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46789 }
46790 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46791 {
46792 arg2 = &temp2;
46793 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46794 }
46795 {
46796 PyThreadState* __tstate = wxPyBeginAllowThreads();
46797 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46798 wxPyEndAllowThreads(__tstate);
46799 if (PyErr_Occurred()) SWIG_fail;
46800 }
46801 resultobj = SWIG_Py_Void();
46802 return resultobj;
46803 fail:
46804 return NULL;
46805 }
46806
46807
46808 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46809 PyObject *resultobj = 0;
46810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46811 wxColour result;
46812 void *argp1 = 0 ;
46813 int res1 = 0 ;
46814 PyObject *swig_obj[1] ;
46815
46816 if (!args) SWIG_fail;
46817 swig_obj[0] = args;
46818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46819 if (!SWIG_IsOK(res1)) {
46820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46821 }
46822 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46823 {
46824 PyThreadState* __tstate = wxPyBeginAllowThreads();
46825 result = wxMenuItem_GetBackgroundColour(arg1);
46826 wxPyEndAllowThreads(__tstate);
46827 if (PyErr_Occurred()) SWIG_fail;
46828 }
46829 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46830 return resultobj;
46831 fail:
46832 return NULL;
46833 }
46834
46835
46836 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46837 PyObject *resultobj = 0;
46838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46839 wxBitmap *arg2 = 0 ;
46840 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46841 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46842 void *argp1 = 0 ;
46843 int res1 = 0 ;
46844 void *argp2 = 0 ;
46845 int res2 = 0 ;
46846 void *argp3 = 0 ;
46847 int res3 = 0 ;
46848 PyObject * obj0 = 0 ;
46849 PyObject * obj1 = 0 ;
46850 PyObject * obj2 = 0 ;
46851 char * kwnames[] = {
46852 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46853 };
46854
46855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46857 if (!SWIG_IsOK(res1)) {
46858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46859 }
46860 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46862 if (!SWIG_IsOK(res2)) {
46863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46864 }
46865 if (!argp2) {
46866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46867 }
46868 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46869 if (obj2) {
46870 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46871 if (!SWIG_IsOK(res3)) {
46872 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46873 }
46874 if (!argp3) {
46875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46876 }
46877 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46878 }
46879 {
46880 PyThreadState* __tstate = wxPyBeginAllowThreads();
46881 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46882 wxPyEndAllowThreads(__tstate);
46883 if (PyErr_Occurred()) SWIG_fail;
46884 }
46885 resultobj = SWIG_Py_Void();
46886 return resultobj;
46887 fail:
46888 return NULL;
46889 }
46890
46891
46892 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46893 PyObject *resultobj = 0;
46894 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46895 wxBitmap *arg2 = 0 ;
46896 void *argp1 = 0 ;
46897 int res1 = 0 ;
46898 void *argp2 = 0 ;
46899 int res2 = 0 ;
46900 PyObject * obj0 = 0 ;
46901 PyObject * obj1 = 0 ;
46902 char * kwnames[] = {
46903 (char *) "self",(char *) "bmpDisabled", NULL
46904 };
46905
46906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46908 if (!SWIG_IsOK(res1)) {
46909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46910 }
46911 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46913 if (!SWIG_IsOK(res2)) {
46914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46915 }
46916 if (!argp2) {
46917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46918 }
46919 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46920 {
46921 PyThreadState* __tstate = wxPyBeginAllowThreads();
46922 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46923 wxPyEndAllowThreads(__tstate);
46924 if (PyErr_Occurred()) SWIG_fail;
46925 }
46926 resultobj = SWIG_Py_Void();
46927 return resultobj;
46928 fail:
46929 return NULL;
46930 }
46931
46932
46933 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46934 PyObject *resultobj = 0;
46935 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46936 wxBitmap *result = 0 ;
46937 void *argp1 = 0 ;
46938 int res1 = 0 ;
46939 PyObject *swig_obj[1] ;
46940
46941 if (!args) SWIG_fail;
46942 swig_obj[0] = args;
46943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46944 if (!SWIG_IsOK(res1)) {
46945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46946 }
46947 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46948 {
46949 PyThreadState* __tstate = wxPyBeginAllowThreads();
46950 {
46951 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
46952 result = (wxBitmap *) &_result_ref;
46953 }
46954 wxPyEndAllowThreads(__tstate);
46955 if (PyErr_Occurred()) SWIG_fail;
46956 }
46957 {
46958 wxBitmap* resultptr = new wxBitmap(*result);
46959 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46960 }
46961 return resultobj;
46962 fail:
46963 return NULL;
46964 }
46965
46966
46967 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46968 PyObject *resultobj = 0;
46969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46970 int arg2 ;
46971 void *argp1 = 0 ;
46972 int res1 = 0 ;
46973 int val2 ;
46974 int ecode2 = 0 ;
46975 PyObject * obj0 = 0 ;
46976 PyObject * obj1 = 0 ;
46977 char * kwnames[] = {
46978 (char *) "self",(char *) "nWidth", NULL
46979 };
46980
46981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
46982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46983 if (!SWIG_IsOK(res1)) {
46984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46985 }
46986 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46987 ecode2 = SWIG_AsVal_int(obj1, &val2);
46988 if (!SWIG_IsOK(ecode2)) {
46989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
46990 }
46991 arg2 = static_cast< int >(val2);
46992 {
46993 PyThreadState* __tstate = wxPyBeginAllowThreads();
46994 wxMenuItem_SetMarginWidth(arg1,arg2);
46995 wxPyEndAllowThreads(__tstate);
46996 if (PyErr_Occurred()) SWIG_fail;
46997 }
46998 resultobj = SWIG_Py_Void();
46999 return resultobj;
47000 fail:
47001 return NULL;
47002 }
47003
47004
47005 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47006 PyObject *resultobj = 0;
47007 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47008 int result;
47009 void *argp1 = 0 ;
47010 int res1 = 0 ;
47011 PyObject *swig_obj[1] ;
47012
47013 if (!args) SWIG_fail;
47014 swig_obj[0] = args;
47015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47016 if (!SWIG_IsOK(res1)) {
47017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47018 }
47019 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 result = (int)wxMenuItem_GetMarginWidth(arg1);
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 resultobj = SWIG_From_int(static_cast< int >(result));
47027 return resultobj;
47028 fail:
47029 return NULL;
47030 }
47031
47032
47033 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47034 PyObject *resultobj = 0;
47035 int result;
47036
47037 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47038 {
47039 PyThreadState* __tstate = wxPyBeginAllowThreads();
47040 result = (int)wxMenuItem_GetDefaultMarginWidth();
47041 wxPyEndAllowThreads(__tstate);
47042 if (PyErr_Occurred()) SWIG_fail;
47043 }
47044 resultobj = SWIG_From_int(static_cast< int >(result));
47045 return resultobj;
47046 fail:
47047 return NULL;
47048 }
47049
47050
47051 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47052 PyObject *resultobj = 0;
47053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47054 bool result;
47055 void *argp1 = 0 ;
47056 int res1 = 0 ;
47057 PyObject *swig_obj[1] ;
47058
47059 if (!args) SWIG_fail;
47060 swig_obj[0] = args;
47061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47062 if (!SWIG_IsOK(res1)) {
47063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47064 }
47065 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47066 {
47067 PyThreadState* __tstate = wxPyBeginAllowThreads();
47068 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47069 wxPyEndAllowThreads(__tstate);
47070 if (PyErr_Occurred()) SWIG_fail;
47071 }
47072 {
47073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47074 }
47075 return resultobj;
47076 fail:
47077 return NULL;
47078 }
47079
47080
47081 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47082 PyObject *resultobj = 0;
47083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47084 bool arg2 = (bool) true ;
47085 void *argp1 = 0 ;
47086 int res1 = 0 ;
47087 bool val2 ;
47088 int ecode2 = 0 ;
47089 PyObject * obj0 = 0 ;
47090 PyObject * obj1 = 0 ;
47091 char * kwnames[] = {
47092 (char *) "self",(char *) "ownerDrawn", NULL
47093 };
47094
47095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47097 if (!SWIG_IsOK(res1)) {
47098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47099 }
47100 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47101 if (obj1) {
47102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47103 if (!SWIG_IsOK(ecode2)) {
47104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47105 }
47106 arg2 = static_cast< bool >(val2);
47107 }
47108 {
47109 PyThreadState* __tstate = wxPyBeginAllowThreads();
47110 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47111 wxPyEndAllowThreads(__tstate);
47112 if (PyErr_Occurred()) SWIG_fail;
47113 }
47114 resultobj = SWIG_Py_Void();
47115 return resultobj;
47116 fail:
47117 return NULL;
47118 }
47119
47120
47121 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47122 PyObject *resultobj = 0;
47123 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47124 void *argp1 = 0 ;
47125 int res1 = 0 ;
47126 PyObject *swig_obj[1] ;
47127
47128 if (!args) SWIG_fail;
47129 swig_obj[0] = args;
47130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47131 if (!SWIG_IsOK(res1)) {
47132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47133 }
47134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47135 {
47136 PyThreadState* __tstate = wxPyBeginAllowThreads();
47137 wxMenuItem_ResetOwnerDrawn(arg1);
47138 wxPyEndAllowThreads(__tstate);
47139 if (PyErr_Occurred()) SWIG_fail;
47140 }
47141 resultobj = SWIG_Py_Void();
47142 return resultobj;
47143 fail:
47144 return NULL;
47145 }
47146
47147
47148 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47149 PyObject *obj;
47150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47151 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47152 return SWIG_Py_Void();
47153 }
47154
47155 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47156 return SWIG_Python_InitShadowInstance(args);
47157 }
47158
47159 SWIGINTERN int ControlNameStr_set(PyObject *) {
47160 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47161 return 1;
47162 }
47163
47164
47165 SWIGINTERN PyObject *ControlNameStr_get(void) {
47166 PyObject *pyobj = 0;
47167
47168 {
47169 #if wxUSE_UNICODE
47170 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47171 #else
47172 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47173 #endif
47174 }
47175 return pyobj;
47176 }
47177
47178
47179 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47180 PyObject *resultobj = 0;
47181 wxWindow *arg1 = (wxWindow *) 0 ;
47182 int arg2 = (int) -1 ;
47183 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47184 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47185 wxSize const &arg4_defvalue = wxDefaultSize ;
47186 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47187 long arg5 = (long) 0 ;
47188 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47189 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47190 wxString const &arg7_defvalue = wxPyControlNameStr ;
47191 wxString *arg7 = (wxString *) &arg7_defvalue ;
47192 wxControl *result = 0 ;
47193 void *argp1 = 0 ;
47194 int res1 = 0 ;
47195 int val2 ;
47196 int ecode2 = 0 ;
47197 wxPoint temp3 ;
47198 wxSize temp4 ;
47199 long val5 ;
47200 int ecode5 = 0 ;
47201 void *argp6 = 0 ;
47202 int res6 = 0 ;
47203 bool temp7 = false ;
47204 PyObject * obj0 = 0 ;
47205 PyObject * obj1 = 0 ;
47206 PyObject * obj2 = 0 ;
47207 PyObject * obj3 = 0 ;
47208 PyObject * obj4 = 0 ;
47209 PyObject * obj5 = 0 ;
47210 PyObject * obj6 = 0 ;
47211 char * kwnames[] = {
47212 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47213 };
47214
47215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47217 if (!SWIG_IsOK(res1)) {
47218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47219 }
47220 arg1 = reinterpret_cast< wxWindow * >(argp1);
47221 if (obj1) {
47222 ecode2 = SWIG_AsVal_int(obj1, &val2);
47223 if (!SWIG_IsOK(ecode2)) {
47224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47225 }
47226 arg2 = static_cast< int >(val2);
47227 }
47228 if (obj2) {
47229 {
47230 arg3 = &temp3;
47231 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47232 }
47233 }
47234 if (obj3) {
47235 {
47236 arg4 = &temp4;
47237 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47238 }
47239 }
47240 if (obj4) {
47241 ecode5 = SWIG_AsVal_long(obj4, &val5);
47242 if (!SWIG_IsOK(ecode5)) {
47243 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47244 }
47245 arg5 = static_cast< long >(val5);
47246 }
47247 if (obj5) {
47248 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47249 if (!SWIG_IsOK(res6)) {
47250 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47251 }
47252 if (!argp6) {
47253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47254 }
47255 arg6 = reinterpret_cast< wxValidator * >(argp6);
47256 }
47257 if (obj6) {
47258 {
47259 arg7 = wxString_in_helper(obj6);
47260 if (arg7 == NULL) SWIG_fail;
47261 temp7 = true;
47262 }
47263 }
47264 {
47265 if (!wxPyCheckForApp()) SWIG_fail;
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47272 {
47273 if (temp7)
47274 delete arg7;
47275 }
47276 return resultobj;
47277 fail:
47278 {
47279 if (temp7)
47280 delete arg7;
47281 }
47282 return NULL;
47283 }
47284
47285
47286 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 PyObject *resultobj = 0;
47288 wxControl *result = 0 ;
47289
47290 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47291 {
47292 if (!wxPyCheckForApp()) SWIG_fail;
47293 PyThreadState* __tstate = wxPyBeginAllowThreads();
47294 result = (wxControl *)new wxControl();
47295 wxPyEndAllowThreads(__tstate);
47296 if (PyErr_Occurred()) SWIG_fail;
47297 }
47298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47299 return resultobj;
47300 fail:
47301 return NULL;
47302 }
47303
47304
47305 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47306 PyObject *resultobj = 0;
47307 wxControl *arg1 = (wxControl *) 0 ;
47308 wxWindow *arg2 = (wxWindow *) 0 ;
47309 int arg3 = (int) -1 ;
47310 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47311 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47312 wxSize const &arg5_defvalue = wxDefaultSize ;
47313 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47314 long arg6 = (long) 0 ;
47315 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47316 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47317 wxString const &arg8_defvalue = wxPyControlNameStr ;
47318 wxString *arg8 = (wxString *) &arg8_defvalue ;
47319 bool result;
47320 void *argp1 = 0 ;
47321 int res1 = 0 ;
47322 void *argp2 = 0 ;
47323 int res2 = 0 ;
47324 int val3 ;
47325 int ecode3 = 0 ;
47326 wxPoint temp4 ;
47327 wxSize temp5 ;
47328 long val6 ;
47329 int ecode6 = 0 ;
47330 void *argp7 = 0 ;
47331 int res7 = 0 ;
47332 bool temp8 = false ;
47333 PyObject * obj0 = 0 ;
47334 PyObject * obj1 = 0 ;
47335 PyObject * obj2 = 0 ;
47336 PyObject * obj3 = 0 ;
47337 PyObject * obj4 = 0 ;
47338 PyObject * obj5 = 0 ;
47339 PyObject * obj6 = 0 ;
47340 PyObject * obj7 = 0 ;
47341 char * kwnames[] = {
47342 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47343 };
47344
47345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47347 if (!SWIG_IsOK(res1)) {
47348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47349 }
47350 arg1 = reinterpret_cast< wxControl * >(argp1);
47351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47352 if (!SWIG_IsOK(res2)) {
47353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47354 }
47355 arg2 = reinterpret_cast< wxWindow * >(argp2);
47356 if (obj2) {
47357 ecode3 = SWIG_AsVal_int(obj2, &val3);
47358 if (!SWIG_IsOK(ecode3)) {
47359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47360 }
47361 arg3 = static_cast< int >(val3);
47362 }
47363 if (obj3) {
47364 {
47365 arg4 = &temp4;
47366 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47367 }
47368 }
47369 if (obj4) {
47370 {
47371 arg5 = &temp5;
47372 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47373 }
47374 }
47375 if (obj5) {
47376 ecode6 = SWIG_AsVal_long(obj5, &val6);
47377 if (!SWIG_IsOK(ecode6)) {
47378 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47379 }
47380 arg6 = static_cast< long >(val6);
47381 }
47382 if (obj6) {
47383 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47384 if (!SWIG_IsOK(res7)) {
47385 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47386 }
47387 if (!argp7) {
47388 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47389 }
47390 arg7 = reinterpret_cast< wxValidator * >(argp7);
47391 }
47392 if (obj7) {
47393 {
47394 arg8 = wxString_in_helper(obj7);
47395 if (arg8 == NULL) SWIG_fail;
47396 temp8 = true;
47397 }
47398 }
47399 {
47400 PyThreadState* __tstate = wxPyBeginAllowThreads();
47401 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47402 wxPyEndAllowThreads(__tstate);
47403 if (PyErr_Occurred()) SWIG_fail;
47404 }
47405 {
47406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47407 }
47408 {
47409 if (temp8)
47410 delete arg8;
47411 }
47412 return resultobj;
47413 fail:
47414 {
47415 if (temp8)
47416 delete arg8;
47417 }
47418 return NULL;
47419 }
47420
47421
47422 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47423 PyObject *resultobj = 0;
47424 wxControl *arg1 = (wxControl *) 0 ;
47425 int result;
47426 void *argp1 = 0 ;
47427 int res1 = 0 ;
47428 PyObject *swig_obj[1] ;
47429
47430 if (!args) SWIG_fail;
47431 swig_obj[0] = args;
47432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47433 if (!SWIG_IsOK(res1)) {
47434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47435 }
47436 arg1 = reinterpret_cast< wxControl * >(argp1);
47437 {
47438 PyThreadState* __tstate = wxPyBeginAllowThreads();
47439 result = (int)((wxControl const *)arg1)->GetAlignment();
47440 wxPyEndAllowThreads(__tstate);
47441 if (PyErr_Occurred()) SWIG_fail;
47442 }
47443 resultobj = SWIG_From_int(static_cast< int >(result));
47444 return resultobj;
47445 fail:
47446 return NULL;
47447 }
47448
47449
47450 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47451 PyObject *resultobj = 0;
47452 wxControl *arg1 = (wxControl *) 0 ;
47453 wxString result;
47454 void *argp1 = 0 ;
47455 int res1 = 0 ;
47456 PyObject *swig_obj[1] ;
47457
47458 if (!args) SWIG_fail;
47459 swig_obj[0] = args;
47460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47463 }
47464 arg1 = reinterpret_cast< wxControl * >(argp1);
47465 {
47466 PyThreadState* __tstate = wxPyBeginAllowThreads();
47467 result = ((wxControl const *)arg1)->GetLabelText();
47468 wxPyEndAllowThreads(__tstate);
47469 if (PyErr_Occurred()) SWIG_fail;
47470 }
47471 {
47472 #if wxUSE_UNICODE
47473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47474 #else
47475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47476 #endif
47477 }
47478 return resultobj;
47479 fail:
47480 return NULL;
47481 }
47482
47483
47484 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47485 PyObject *resultobj = 0;
47486 wxControl *arg1 = (wxControl *) 0 ;
47487 wxCommandEvent *arg2 = 0 ;
47488 void *argp1 = 0 ;
47489 int res1 = 0 ;
47490 void *argp2 = 0 ;
47491 int res2 = 0 ;
47492 PyObject * obj0 = 0 ;
47493 PyObject * obj1 = 0 ;
47494 char * kwnames[] = {
47495 (char *) "self",(char *) "event", NULL
47496 };
47497
47498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47500 if (!SWIG_IsOK(res1)) {
47501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47502 }
47503 arg1 = reinterpret_cast< wxControl * >(argp1);
47504 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47505 if (!SWIG_IsOK(res2)) {
47506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47507 }
47508 if (!argp2) {
47509 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47510 }
47511 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47512 {
47513 PyThreadState* __tstate = wxPyBeginAllowThreads();
47514 (arg1)->Command(*arg2);
47515 wxPyEndAllowThreads(__tstate);
47516 if (PyErr_Occurred()) SWIG_fail;
47517 }
47518 resultobj = SWIG_Py_Void();
47519 return resultobj;
47520 fail:
47521 return NULL;
47522 }
47523
47524
47525 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47526 PyObject *resultobj = 0;
47527 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47528 SwigValueWrapper<wxVisualAttributes > result;
47529 int val1 ;
47530 int ecode1 = 0 ;
47531 PyObject * obj0 = 0 ;
47532 char * kwnames[] = {
47533 (char *) "variant", NULL
47534 };
47535
47536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47537 if (obj0) {
47538 ecode1 = SWIG_AsVal_int(obj0, &val1);
47539 if (!SWIG_IsOK(ecode1)) {
47540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47541 }
47542 arg1 = static_cast< wxWindowVariant >(val1);
47543 }
47544 {
47545 if (!wxPyCheckForApp()) SWIG_fail;
47546 PyThreadState* __tstate = wxPyBeginAllowThreads();
47547 result = wxControl::GetClassDefaultAttributes(arg1);
47548 wxPyEndAllowThreads(__tstate);
47549 if (PyErr_Occurred()) SWIG_fail;
47550 }
47551 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47552 return resultobj;
47553 fail:
47554 return NULL;
47555 }
47556
47557
47558 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47559 PyObject *obj;
47560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47561 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47562 return SWIG_Py_Void();
47563 }
47564
47565 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47566 return SWIG_Python_InitShadowInstance(args);
47567 }
47568
47569 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47570 PyObject *resultobj = 0;
47571 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47572 wxString *arg2 = 0 ;
47573 PyObject *arg3 = (PyObject *) NULL ;
47574 int result;
47575 void *argp1 = 0 ;
47576 int res1 = 0 ;
47577 bool temp2 = false ;
47578 PyObject * obj0 = 0 ;
47579 PyObject * obj1 = 0 ;
47580 PyObject * obj2 = 0 ;
47581 char * kwnames[] = {
47582 (char *) "self",(char *) "item",(char *) "clientData", NULL
47583 };
47584
47585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47587 if (!SWIG_IsOK(res1)) {
47588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47589 }
47590 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47591 {
47592 arg2 = wxString_in_helper(obj1);
47593 if (arg2 == NULL) SWIG_fail;
47594 temp2 = true;
47595 }
47596 if (obj2) {
47597 arg3 = obj2;
47598 }
47599 {
47600 PyThreadState* __tstate = wxPyBeginAllowThreads();
47601 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47602 wxPyEndAllowThreads(__tstate);
47603 if (PyErr_Occurred()) SWIG_fail;
47604 }
47605 resultobj = SWIG_From_int(static_cast< int >(result));
47606 {
47607 if (temp2)
47608 delete arg2;
47609 }
47610 return resultobj;
47611 fail:
47612 {
47613 if (temp2)
47614 delete arg2;
47615 }
47616 return NULL;
47617 }
47618
47619
47620 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47621 PyObject *resultobj = 0;
47622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47623 wxArrayString *arg2 = 0 ;
47624 void *argp1 = 0 ;
47625 int res1 = 0 ;
47626 bool temp2 = false ;
47627 PyObject * obj0 = 0 ;
47628 PyObject * obj1 = 0 ;
47629 char * kwnames[] = {
47630 (char *) "self",(char *) "strings", NULL
47631 };
47632
47633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47635 if (!SWIG_IsOK(res1)) {
47636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47637 }
47638 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47639 {
47640 if (! PySequence_Check(obj1)) {
47641 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47642 SWIG_fail;
47643 }
47644 arg2 = new wxArrayString;
47645 temp2 = true;
47646 int i, len=PySequence_Length(obj1);
47647 for (i=0; i<len; i++) {
47648 PyObject* item = PySequence_GetItem(obj1, i);
47649 wxString* s = wxString_in_helper(item);
47650 if (PyErr_Occurred()) SWIG_fail;
47651 arg2->Add(*s);
47652 delete s;
47653 Py_DECREF(item);
47654 }
47655 }
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 (arg1)->Append((wxArrayString const &)*arg2);
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_Py_Void();
47663 {
47664 if (temp2) delete arg2;
47665 }
47666 return resultobj;
47667 fail:
47668 {
47669 if (temp2) delete arg2;
47670 }
47671 return NULL;
47672 }
47673
47674
47675 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47676 PyObject *resultobj = 0;
47677 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47678 wxString *arg2 = 0 ;
47679 unsigned int arg3 ;
47680 PyObject *arg4 = (PyObject *) NULL ;
47681 int result;
47682 void *argp1 = 0 ;
47683 int res1 = 0 ;
47684 bool temp2 = false ;
47685 unsigned int val3 ;
47686 int ecode3 = 0 ;
47687 PyObject * obj0 = 0 ;
47688 PyObject * obj1 = 0 ;
47689 PyObject * obj2 = 0 ;
47690 PyObject * obj3 = 0 ;
47691 char * kwnames[] = {
47692 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47693 };
47694
47695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47697 if (!SWIG_IsOK(res1)) {
47698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47699 }
47700 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47701 {
47702 arg2 = wxString_in_helper(obj1);
47703 if (arg2 == NULL) SWIG_fail;
47704 temp2 = true;
47705 }
47706 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47707 if (!SWIG_IsOK(ecode3)) {
47708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47709 }
47710 arg3 = static_cast< unsigned int >(val3);
47711 if (obj3) {
47712 arg4 = obj3;
47713 }
47714 {
47715 PyThreadState* __tstate = wxPyBeginAllowThreads();
47716 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47717 wxPyEndAllowThreads(__tstate);
47718 if (PyErr_Occurred()) SWIG_fail;
47719 }
47720 resultobj = SWIG_From_int(static_cast< int >(result));
47721 {
47722 if (temp2)
47723 delete arg2;
47724 }
47725 return resultobj;
47726 fail:
47727 {
47728 if (temp2)
47729 delete arg2;
47730 }
47731 return NULL;
47732 }
47733
47734
47735 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47736 PyObject *resultobj = 0;
47737 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47738 void *argp1 = 0 ;
47739 int res1 = 0 ;
47740 PyObject *swig_obj[1] ;
47741
47742 if (!args) SWIG_fail;
47743 swig_obj[0] = args;
47744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47745 if (!SWIG_IsOK(res1)) {
47746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47747 }
47748 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47749 {
47750 PyThreadState* __tstate = wxPyBeginAllowThreads();
47751 (arg1)->Clear();
47752 wxPyEndAllowThreads(__tstate);
47753 if (PyErr_Occurred()) SWIG_fail;
47754 }
47755 resultobj = SWIG_Py_Void();
47756 return resultobj;
47757 fail:
47758 return NULL;
47759 }
47760
47761
47762 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47763 PyObject *resultobj = 0;
47764 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47765 unsigned int arg2 ;
47766 void *argp1 = 0 ;
47767 int res1 = 0 ;
47768 unsigned int val2 ;
47769 int ecode2 = 0 ;
47770 PyObject * obj0 = 0 ;
47771 PyObject * obj1 = 0 ;
47772 char * kwnames[] = {
47773 (char *) "self",(char *) "n", NULL
47774 };
47775
47776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47778 if (!SWIG_IsOK(res1)) {
47779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47780 }
47781 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47782 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47783 if (!SWIG_IsOK(ecode2)) {
47784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47785 }
47786 arg2 = static_cast< unsigned int >(val2);
47787 {
47788 PyThreadState* __tstate = wxPyBeginAllowThreads();
47789 (arg1)->Delete(arg2);
47790 wxPyEndAllowThreads(__tstate);
47791 if (PyErr_Occurred()) SWIG_fail;
47792 }
47793 resultobj = SWIG_Py_Void();
47794 return resultobj;
47795 fail:
47796 return NULL;
47797 }
47798
47799
47800 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47801 PyObject *resultobj = 0;
47802 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47803 unsigned int arg2 ;
47804 PyObject *result = 0 ;
47805 void *argp1 = 0 ;
47806 int res1 = 0 ;
47807 unsigned int val2 ;
47808 int ecode2 = 0 ;
47809 PyObject * obj0 = 0 ;
47810 PyObject * obj1 = 0 ;
47811 char * kwnames[] = {
47812 (char *) "self",(char *) "n", NULL
47813 };
47814
47815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47817 if (!SWIG_IsOK(res1)) {
47818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47819 }
47820 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47821 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47822 if (!SWIG_IsOK(ecode2)) {
47823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47824 }
47825 arg2 = static_cast< unsigned int >(val2);
47826 {
47827 PyThreadState* __tstate = wxPyBeginAllowThreads();
47828 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47829 wxPyEndAllowThreads(__tstate);
47830 if (PyErr_Occurred()) SWIG_fail;
47831 }
47832 resultobj = result;
47833 return resultobj;
47834 fail:
47835 return NULL;
47836 }
47837
47838
47839 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47840 PyObject *resultobj = 0;
47841 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47842 unsigned int arg2 ;
47843 PyObject *arg3 = (PyObject *) 0 ;
47844 void *argp1 = 0 ;
47845 int res1 = 0 ;
47846 unsigned int val2 ;
47847 int ecode2 = 0 ;
47848 PyObject * obj0 = 0 ;
47849 PyObject * obj1 = 0 ;
47850 PyObject * obj2 = 0 ;
47851 char * kwnames[] = {
47852 (char *) "self",(char *) "n",(char *) "clientData", NULL
47853 };
47854
47855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47857 if (!SWIG_IsOK(res1)) {
47858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47859 }
47860 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47861 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47862 if (!SWIG_IsOK(ecode2)) {
47863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47864 }
47865 arg2 = static_cast< unsigned int >(val2);
47866 arg3 = obj2;
47867 {
47868 PyThreadState* __tstate = wxPyBeginAllowThreads();
47869 wxItemContainer_SetClientData(arg1,arg2,arg3);
47870 wxPyEndAllowThreads(__tstate);
47871 if (PyErr_Occurred()) SWIG_fail;
47872 }
47873 resultobj = SWIG_Py_Void();
47874 return resultobj;
47875 fail:
47876 return NULL;
47877 }
47878
47879
47880 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47881 PyObject *resultobj = 0;
47882 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47883 unsigned int result;
47884 void *argp1 = 0 ;
47885 int res1 = 0 ;
47886 PyObject *swig_obj[1] ;
47887
47888 if (!args) SWIG_fail;
47889 swig_obj[0] = args;
47890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47891 if (!SWIG_IsOK(res1)) {
47892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47893 }
47894 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47895 {
47896 PyThreadState* __tstate = wxPyBeginAllowThreads();
47897 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47898 wxPyEndAllowThreads(__tstate);
47899 if (PyErr_Occurred()) SWIG_fail;
47900 }
47901 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47902 return resultobj;
47903 fail:
47904 return NULL;
47905 }
47906
47907
47908 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47909 PyObject *resultobj = 0;
47910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47911 bool result;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 PyObject *swig_obj[1] ;
47915
47916 if (!args) SWIG_fail;
47917 swig_obj[0] = args;
47918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47919 if (!SWIG_IsOK(res1)) {
47920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47921 }
47922 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47923 {
47924 PyThreadState* __tstate = wxPyBeginAllowThreads();
47925 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47926 wxPyEndAllowThreads(__tstate);
47927 if (PyErr_Occurred()) SWIG_fail;
47928 }
47929 {
47930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47931 }
47932 return resultobj;
47933 fail:
47934 return NULL;
47935 }
47936
47937
47938 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47939 PyObject *resultobj = 0;
47940 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47941 unsigned int arg2 ;
47942 wxString result;
47943 void *argp1 = 0 ;
47944 int res1 = 0 ;
47945 unsigned int val2 ;
47946 int ecode2 = 0 ;
47947 PyObject * obj0 = 0 ;
47948 PyObject * obj1 = 0 ;
47949 char * kwnames[] = {
47950 (char *) "self",(char *) "n", NULL
47951 };
47952
47953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47955 if (!SWIG_IsOK(res1)) {
47956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47957 }
47958 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47959 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47960 if (!SWIG_IsOK(ecode2)) {
47961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
47962 }
47963 arg2 = static_cast< unsigned int >(val2);
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 {
47971 #if wxUSE_UNICODE
47972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47973 #else
47974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47975 #endif
47976 }
47977 return resultobj;
47978 fail:
47979 return NULL;
47980 }
47981
47982
47983 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47984 PyObject *resultobj = 0;
47985 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47986 wxArrayString result;
47987 void *argp1 = 0 ;
47988 int res1 = 0 ;
47989 PyObject *swig_obj[1] ;
47990
47991 if (!args) SWIG_fail;
47992 swig_obj[0] = args;
47993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47994 if (!SWIG_IsOK(res1)) {
47995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47996 }
47997 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47998 {
47999 PyThreadState* __tstate = wxPyBeginAllowThreads();
48000 result = ((wxItemContainer const *)arg1)->GetStrings();
48001 wxPyEndAllowThreads(__tstate);
48002 if (PyErr_Occurred()) SWIG_fail;
48003 }
48004 {
48005 resultobj = wxArrayString2PyList_helper(result);
48006 }
48007 return resultobj;
48008 fail:
48009 return NULL;
48010 }
48011
48012
48013 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48014 PyObject *resultobj = 0;
48015 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48016 unsigned int arg2 ;
48017 wxString *arg3 = 0 ;
48018 void *argp1 = 0 ;
48019 int res1 = 0 ;
48020 unsigned int val2 ;
48021 int ecode2 = 0 ;
48022 bool temp3 = false ;
48023 PyObject * obj0 = 0 ;
48024 PyObject * obj1 = 0 ;
48025 PyObject * obj2 = 0 ;
48026 char * kwnames[] = {
48027 (char *) "self",(char *) "n",(char *) "s", NULL
48028 };
48029
48030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48032 if (!SWIG_IsOK(res1)) {
48033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48034 }
48035 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48036 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48037 if (!SWIG_IsOK(ecode2)) {
48038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48039 }
48040 arg2 = static_cast< unsigned int >(val2);
48041 {
48042 arg3 = wxString_in_helper(obj2);
48043 if (arg3 == NULL) SWIG_fail;
48044 temp3 = true;
48045 }
48046 {
48047 PyThreadState* __tstate = wxPyBeginAllowThreads();
48048 (arg1)->SetString(arg2,(wxString const &)*arg3);
48049 wxPyEndAllowThreads(__tstate);
48050 if (PyErr_Occurred()) SWIG_fail;
48051 }
48052 resultobj = SWIG_Py_Void();
48053 {
48054 if (temp3)
48055 delete arg3;
48056 }
48057 return resultobj;
48058 fail:
48059 {
48060 if (temp3)
48061 delete arg3;
48062 }
48063 return NULL;
48064 }
48065
48066
48067 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48068 PyObject *resultobj = 0;
48069 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48070 wxString *arg2 = 0 ;
48071 int result;
48072 void *argp1 = 0 ;
48073 int res1 = 0 ;
48074 bool temp2 = false ;
48075 PyObject * obj0 = 0 ;
48076 PyObject * obj1 = 0 ;
48077 char * kwnames[] = {
48078 (char *) "self",(char *) "s", NULL
48079 };
48080
48081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48083 if (!SWIG_IsOK(res1)) {
48084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48085 }
48086 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48087 {
48088 arg2 = wxString_in_helper(obj1);
48089 if (arg2 == NULL) SWIG_fail;
48090 temp2 = true;
48091 }
48092 {
48093 PyThreadState* __tstate = wxPyBeginAllowThreads();
48094 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48095 wxPyEndAllowThreads(__tstate);
48096 if (PyErr_Occurred()) SWIG_fail;
48097 }
48098 resultobj = SWIG_From_int(static_cast< int >(result));
48099 {
48100 if (temp2)
48101 delete arg2;
48102 }
48103 return resultobj;
48104 fail:
48105 {
48106 if (temp2)
48107 delete arg2;
48108 }
48109 return NULL;
48110 }
48111
48112
48113 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48114 PyObject *resultobj = 0;
48115 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48116 int arg2 ;
48117 void *argp1 = 0 ;
48118 int res1 = 0 ;
48119 int val2 ;
48120 int ecode2 = 0 ;
48121 PyObject * obj0 = 0 ;
48122 PyObject * obj1 = 0 ;
48123 char * kwnames[] = {
48124 (char *) "self",(char *) "n", NULL
48125 };
48126
48127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48129 if (!SWIG_IsOK(res1)) {
48130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48131 }
48132 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48133 ecode2 = SWIG_AsVal_int(obj1, &val2);
48134 if (!SWIG_IsOK(ecode2)) {
48135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48136 }
48137 arg2 = static_cast< int >(val2);
48138 {
48139 PyThreadState* __tstate = wxPyBeginAllowThreads();
48140 (arg1)->SetSelection(arg2);
48141 wxPyEndAllowThreads(__tstate);
48142 if (PyErr_Occurred()) SWIG_fail;
48143 }
48144 resultobj = SWIG_Py_Void();
48145 return resultobj;
48146 fail:
48147 return NULL;
48148 }
48149
48150
48151 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48152 PyObject *resultobj = 0;
48153 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48154 int result;
48155 void *argp1 = 0 ;
48156 int res1 = 0 ;
48157 PyObject *swig_obj[1] ;
48158
48159 if (!args) SWIG_fail;
48160 swig_obj[0] = args;
48161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48162 if (!SWIG_IsOK(res1)) {
48163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48164 }
48165 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48166 {
48167 PyThreadState* __tstate = wxPyBeginAllowThreads();
48168 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48169 wxPyEndAllowThreads(__tstate);
48170 if (PyErr_Occurred()) SWIG_fail;
48171 }
48172 resultobj = SWIG_From_int(static_cast< int >(result));
48173 return resultobj;
48174 fail:
48175 return NULL;
48176 }
48177
48178
48179 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48180 PyObject *resultobj = 0;
48181 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48182 wxString *arg2 = 0 ;
48183 bool result;
48184 void *argp1 = 0 ;
48185 int res1 = 0 ;
48186 bool temp2 = false ;
48187 PyObject * obj0 = 0 ;
48188 PyObject * obj1 = 0 ;
48189 char * kwnames[] = {
48190 (char *) "self",(char *) "s", NULL
48191 };
48192
48193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48195 if (!SWIG_IsOK(res1)) {
48196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48197 }
48198 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48199 {
48200 arg2 = wxString_in_helper(obj1);
48201 if (arg2 == NULL) SWIG_fail;
48202 temp2 = true;
48203 }
48204 {
48205 PyThreadState* __tstate = wxPyBeginAllowThreads();
48206 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48207 wxPyEndAllowThreads(__tstate);
48208 if (PyErr_Occurred()) SWIG_fail;
48209 }
48210 {
48211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48212 }
48213 {
48214 if (temp2)
48215 delete arg2;
48216 }
48217 return resultobj;
48218 fail:
48219 {
48220 if (temp2)
48221 delete arg2;
48222 }
48223 return NULL;
48224 }
48225
48226
48227 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48228 PyObject *resultobj = 0;
48229 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48230 wxString result;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 PyObject *swig_obj[1] ;
48234
48235 if (!args) SWIG_fail;
48236 swig_obj[0] = args;
48237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48240 }
48241 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48242 {
48243 PyThreadState* __tstate = wxPyBeginAllowThreads();
48244 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48245 wxPyEndAllowThreads(__tstate);
48246 if (PyErr_Occurred()) SWIG_fail;
48247 }
48248 {
48249 #if wxUSE_UNICODE
48250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48251 #else
48252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48253 #endif
48254 }
48255 return resultobj;
48256 fail:
48257 return NULL;
48258 }
48259
48260
48261 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48262 PyObject *resultobj = 0;
48263 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48264 int arg2 ;
48265 void *argp1 = 0 ;
48266 int res1 = 0 ;
48267 int val2 ;
48268 int ecode2 = 0 ;
48269 PyObject * obj0 = 0 ;
48270 PyObject * obj1 = 0 ;
48271 char * kwnames[] = {
48272 (char *) "self",(char *) "n", NULL
48273 };
48274
48275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48277 if (!SWIG_IsOK(res1)) {
48278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48279 }
48280 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48281 ecode2 = SWIG_AsVal_int(obj1, &val2);
48282 if (!SWIG_IsOK(ecode2)) {
48283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48284 }
48285 arg2 = static_cast< int >(val2);
48286 {
48287 PyThreadState* __tstate = wxPyBeginAllowThreads();
48288 (arg1)->Select(arg2);
48289 wxPyEndAllowThreads(__tstate);
48290 if (PyErr_Occurred()) SWIG_fail;
48291 }
48292 resultobj = SWIG_Py_Void();
48293 return resultobj;
48294 fail:
48295 return NULL;
48296 }
48297
48298
48299 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48300 PyObject *obj;
48301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48302 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48303 return SWIG_Py_Void();
48304 }
48305
48306 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48307 PyObject *obj;
48308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48309 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48310 return SWIG_Py_Void();
48311 }
48312
48313 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48314 PyObject *resultobj = 0;
48315 wxSizerItem *result = 0 ;
48316
48317 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48318 {
48319 PyThreadState* __tstate = wxPyBeginAllowThreads();
48320 result = (wxSizerItem *)new wxSizerItem();
48321 wxPyEndAllowThreads(__tstate);
48322 if (PyErr_Occurred()) SWIG_fail;
48323 }
48324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48332 PyObject *resultobj = 0;
48333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48334 void *argp1 = 0 ;
48335 int res1 = 0 ;
48336 PyObject *swig_obj[1] ;
48337
48338 if (!args) SWIG_fail;
48339 swig_obj[0] = args;
48340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48341 if (!SWIG_IsOK(res1)) {
48342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48343 }
48344 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48345 {
48346 PyThreadState* __tstate = wxPyBeginAllowThreads();
48347 delete arg1;
48348
48349 wxPyEndAllowThreads(__tstate);
48350 if (PyErr_Occurred()) SWIG_fail;
48351 }
48352 resultobj = SWIG_Py_Void();
48353 return resultobj;
48354 fail:
48355 return NULL;
48356 }
48357
48358
48359 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48360 PyObject *resultobj = 0;
48361 wxWindow *arg1 = (wxWindow *) 0 ;
48362 int arg2 ;
48363 int arg3 ;
48364 int arg4 ;
48365 PyObject *arg5 = (PyObject *) NULL ;
48366 wxSizerItem *result = 0 ;
48367 void *argp1 = 0 ;
48368 int res1 = 0 ;
48369 int val2 ;
48370 int ecode2 = 0 ;
48371 int val3 ;
48372 int ecode3 = 0 ;
48373 int val4 ;
48374 int ecode4 = 0 ;
48375 PyObject * obj0 = 0 ;
48376 PyObject * obj1 = 0 ;
48377 PyObject * obj2 = 0 ;
48378 PyObject * obj3 = 0 ;
48379 PyObject * obj4 = 0 ;
48380 char * kwnames[] = {
48381 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48382 };
48383
48384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48386 if (!SWIG_IsOK(res1)) {
48387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48388 }
48389 arg1 = reinterpret_cast< wxWindow * >(argp1);
48390 ecode2 = SWIG_AsVal_int(obj1, &val2);
48391 if (!SWIG_IsOK(ecode2)) {
48392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48393 }
48394 arg2 = static_cast< int >(val2);
48395 ecode3 = SWIG_AsVal_int(obj2, &val3);
48396 if (!SWIG_IsOK(ecode3)) {
48397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48398 }
48399 arg3 = static_cast< int >(val3);
48400 ecode4 = SWIG_AsVal_int(obj3, &val4);
48401 if (!SWIG_IsOK(ecode4)) {
48402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48403 }
48404 arg4 = static_cast< int >(val4);
48405 if (obj4) {
48406 arg5 = obj4;
48407 }
48408 {
48409 PyThreadState* __tstate = wxPyBeginAllowThreads();
48410 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48411 wxPyEndAllowThreads(__tstate);
48412 if (PyErr_Occurred()) SWIG_fail;
48413 }
48414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48415 return resultobj;
48416 fail:
48417 return NULL;
48418 }
48419
48420
48421 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48422 PyObject *resultobj = 0;
48423 int arg1 ;
48424 int arg2 ;
48425 int arg3 ;
48426 int arg4 ;
48427 int arg5 ;
48428 PyObject *arg6 = (PyObject *) NULL ;
48429 wxSizerItem *result = 0 ;
48430 int val1 ;
48431 int ecode1 = 0 ;
48432 int val2 ;
48433 int ecode2 = 0 ;
48434 int val3 ;
48435 int ecode3 = 0 ;
48436 int val4 ;
48437 int ecode4 = 0 ;
48438 int val5 ;
48439 int ecode5 = 0 ;
48440 PyObject * obj0 = 0 ;
48441 PyObject * obj1 = 0 ;
48442 PyObject * obj2 = 0 ;
48443 PyObject * obj3 = 0 ;
48444 PyObject * obj4 = 0 ;
48445 PyObject * obj5 = 0 ;
48446 char * kwnames[] = {
48447 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48448 };
48449
48450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48451 ecode1 = SWIG_AsVal_int(obj0, &val1);
48452 if (!SWIG_IsOK(ecode1)) {
48453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48454 }
48455 arg1 = static_cast< int >(val1);
48456 ecode2 = SWIG_AsVal_int(obj1, &val2);
48457 if (!SWIG_IsOK(ecode2)) {
48458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48459 }
48460 arg2 = static_cast< int >(val2);
48461 ecode3 = SWIG_AsVal_int(obj2, &val3);
48462 if (!SWIG_IsOK(ecode3)) {
48463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48464 }
48465 arg3 = static_cast< int >(val3);
48466 ecode4 = SWIG_AsVal_int(obj3, &val4);
48467 if (!SWIG_IsOK(ecode4)) {
48468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48469 }
48470 arg4 = static_cast< int >(val4);
48471 ecode5 = SWIG_AsVal_int(obj4, &val5);
48472 if (!SWIG_IsOK(ecode5)) {
48473 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48474 }
48475 arg5 = static_cast< int >(val5);
48476 if (obj5) {
48477 arg6 = obj5;
48478 }
48479 {
48480 PyThreadState* __tstate = wxPyBeginAllowThreads();
48481 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48482 wxPyEndAllowThreads(__tstate);
48483 if (PyErr_Occurred()) SWIG_fail;
48484 }
48485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48486 return resultobj;
48487 fail:
48488 return NULL;
48489 }
48490
48491
48492 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48493 PyObject *resultobj = 0;
48494 wxSizer *arg1 = (wxSizer *) 0 ;
48495 int arg2 ;
48496 int arg3 ;
48497 int arg4 ;
48498 PyObject *arg5 = (PyObject *) NULL ;
48499 wxSizerItem *result = 0 ;
48500 int res1 = 0 ;
48501 int val2 ;
48502 int ecode2 = 0 ;
48503 int val3 ;
48504 int ecode3 = 0 ;
48505 int val4 ;
48506 int ecode4 = 0 ;
48507 PyObject * obj0 = 0 ;
48508 PyObject * obj1 = 0 ;
48509 PyObject * obj2 = 0 ;
48510 PyObject * obj3 = 0 ;
48511 PyObject * obj4 = 0 ;
48512 char * kwnames[] = {
48513 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48514 };
48515
48516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48517 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48518 if (!SWIG_IsOK(res1)) {
48519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48520 }
48521 ecode2 = SWIG_AsVal_int(obj1, &val2);
48522 if (!SWIG_IsOK(ecode2)) {
48523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48524 }
48525 arg2 = static_cast< int >(val2);
48526 ecode3 = SWIG_AsVal_int(obj2, &val3);
48527 if (!SWIG_IsOK(ecode3)) {
48528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48529 }
48530 arg3 = static_cast< int >(val3);
48531 ecode4 = SWIG_AsVal_int(obj3, &val4);
48532 if (!SWIG_IsOK(ecode4)) {
48533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48534 }
48535 arg4 = static_cast< int >(val4);
48536 if (obj4) {
48537 arg5 = obj4;
48538 }
48539 {
48540 PyThreadState* __tstate = wxPyBeginAllowThreads();
48541 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48542 wxPyEndAllowThreads(__tstate);
48543 if (PyErr_Occurred()) SWIG_fail;
48544 }
48545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48546 return resultobj;
48547 fail:
48548 return NULL;
48549 }
48550
48551
48552 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48553 PyObject *resultobj = 0;
48554 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48555 void *argp1 = 0 ;
48556 int res1 = 0 ;
48557 PyObject *swig_obj[1] ;
48558
48559 if (!args) SWIG_fail;
48560 swig_obj[0] = args;
48561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48562 if (!SWIG_IsOK(res1)) {
48563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48564 }
48565 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48566 {
48567 PyThreadState* __tstate = wxPyBeginAllowThreads();
48568 (arg1)->DeleteWindows();
48569 wxPyEndAllowThreads(__tstate);
48570 if (PyErr_Occurred()) SWIG_fail;
48571 }
48572 resultobj = SWIG_Py_Void();
48573 return resultobj;
48574 fail:
48575 return NULL;
48576 }
48577
48578
48579 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48580 PyObject *resultobj = 0;
48581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48582 void *argp1 = 0 ;
48583 int res1 = 0 ;
48584 PyObject *swig_obj[1] ;
48585
48586 if (!args) SWIG_fail;
48587 swig_obj[0] = args;
48588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48589 if (!SWIG_IsOK(res1)) {
48590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48591 }
48592 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48593 {
48594 PyThreadState* __tstate = wxPyBeginAllowThreads();
48595 (arg1)->DetachSizer();
48596 wxPyEndAllowThreads(__tstate);
48597 if (PyErr_Occurred()) SWIG_fail;
48598 }
48599 resultobj = SWIG_Py_Void();
48600 return resultobj;
48601 fail:
48602 return NULL;
48603 }
48604
48605
48606 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48607 PyObject *resultobj = 0;
48608 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48609 wxSize result;
48610 void *argp1 = 0 ;
48611 int res1 = 0 ;
48612 PyObject *swig_obj[1] ;
48613
48614 if (!args) SWIG_fail;
48615 swig_obj[0] = args;
48616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48617 if (!SWIG_IsOK(res1)) {
48618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48619 }
48620 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 result = (arg1)->GetSize();
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48628 return resultobj;
48629 fail:
48630 return NULL;
48631 }
48632
48633
48634 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 PyObject *resultobj = 0;
48636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48637 wxSize result;
48638 void *argp1 = 0 ;
48639 int res1 = 0 ;
48640 PyObject *swig_obj[1] ;
48641
48642 if (!args) SWIG_fail;
48643 swig_obj[0] = args;
48644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48647 }
48648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 result = (arg1)->CalcMin();
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48656 return resultobj;
48657 fail:
48658 return NULL;
48659 }
48660
48661
48662 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48663 PyObject *resultobj = 0;
48664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48665 wxPoint *arg2 = 0 ;
48666 wxSize *arg3 = 0 ;
48667 void *argp1 = 0 ;
48668 int res1 = 0 ;
48669 wxPoint temp2 ;
48670 wxSize temp3 ;
48671 PyObject * obj0 = 0 ;
48672 PyObject * obj1 = 0 ;
48673 PyObject * obj2 = 0 ;
48674 char * kwnames[] = {
48675 (char *) "self",(char *) "pos",(char *) "size", NULL
48676 };
48677
48678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48680 if (!SWIG_IsOK(res1)) {
48681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48682 }
48683 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48684 {
48685 arg2 = &temp2;
48686 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48687 }
48688 {
48689 arg3 = &temp3;
48690 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48691 }
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_Py_Void();
48699 return resultobj;
48700 fail:
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 PyObject *resultobj = 0;
48707 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48708 wxSize result;
48709 void *argp1 = 0 ;
48710 int res1 = 0 ;
48711 PyObject *swig_obj[1] ;
48712
48713 if (!args) SWIG_fail;
48714 swig_obj[0] = args;
48715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48716 if (!SWIG_IsOK(res1)) {
48717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48718 }
48719 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48720 {
48721 PyThreadState* __tstate = wxPyBeginAllowThreads();
48722 result = (arg1)->GetMinSize();
48723 wxPyEndAllowThreads(__tstate);
48724 if (PyErr_Occurred()) SWIG_fail;
48725 }
48726 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48727 return resultobj;
48728 fail:
48729 return NULL;
48730 }
48731
48732
48733 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48734 PyObject *resultobj = 0;
48735 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48736 wxSize result;
48737 void *argp1 = 0 ;
48738 int res1 = 0 ;
48739 PyObject *swig_obj[1] ;
48740
48741 if (!args) SWIG_fail;
48742 swig_obj[0] = args;
48743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48744 if (!SWIG_IsOK(res1)) {
48745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48746 }
48747 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48748 {
48749 PyThreadState* __tstate = wxPyBeginAllowThreads();
48750 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48751 wxPyEndAllowThreads(__tstate);
48752 if (PyErr_Occurred()) SWIG_fail;
48753 }
48754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48755 return resultobj;
48756 fail:
48757 return NULL;
48758 }
48759
48760
48761 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48762 PyObject *resultobj = 0;
48763 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48764 int arg2 ;
48765 int arg3 ;
48766 void *argp1 = 0 ;
48767 int res1 = 0 ;
48768 int val2 ;
48769 int ecode2 = 0 ;
48770 int val3 ;
48771 int ecode3 = 0 ;
48772 PyObject * obj0 = 0 ;
48773 PyObject * obj1 = 0 ;
48774 PyObject * obj2 = 0 ;
48775 char * kwnames[] = {
48776 (char *) "self",(char *) "x",(char *) "y", NULL
48777 };
48778
48779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48783 }
48784 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48785 ecode2 = SWIG_AsVal_int(obj1, &val2);
48786 if (!SWIG_IsOK(ecode2)) {
48787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48788 }
48789 arg2 = static_cast< int >(val2);
48790 ecode3 = SWIG_AsVal_int(obj2, &val3);
48791 if (!SWIG_IsOK(ecode3)) {
48792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48793 }
48794 arg3 = static_cast< int >(val3);
48795 {
48796 PyThreadState* __tstate = wxPyBeginAllowThreads();
48797 (arg1)->SetInitSize(arg2,arg3);
48798 wxPyEndAllowThreads(__tstate);
48799 if (PyErr_Occurred()) SWIG_fail;
48800 }
48801 resultobj = SWIG_Py_Void();
48802 return resultobj;
48803 fail:
48804 return NULL;
48805 }
48806
48807
48808 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48809 PyObject *resultobj = 0;
48810 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48811 int arg2 ;
48812 int arg3 ;
48813 void *argp1 = 0 ;
48814 int res1 = 0 ;
48815 int val2 ;
48816 int ecode2 = 0 ;
48817 int val3 ;
48818 int ecode3 = 0 ;
48819 PyObject * obj0 = 0 ;
48820 PyObject * obj1 = 0 ;
48821 PyObject * obj2 = 0 ;
48822 char * kwnames[] = {
48823 (char *) "self",(char *) "width",(char *) "height", NULL
48824 };
48825
48826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48828 if (!SWIG_IsOK(res1)) {
48829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48830 }
48831 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48832 ecode2 = SWIG_AsVal_int(obj1, &val2);
48833 if (!SWIG_IsOK(ecode2)) {
48834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48835 }
48836 arg2 = static_cast< int >(val2);
48837 ecode3 = SWIG_AsVal_int(obj2, &val3);
48838 if (!SWIG_IsOK(ecode3)) {
48839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48840 }
48841 arg3 = static_cast< int >(val3);
48842 {
48843 PyThreadState* __tstate = wxPyBeginAllowThreads();
48844 (arg1)->SetRatio(arg2,arg3);
48845 wxPyEndAllowThreads(__tstate);
48846 if (PyErr_Occurred()) SWIG_fail;
48847 }
48848 resultobj = SWIG_Py_Void();
48849 return resultobj;
48850 fail:
48851 return NULL;
48852 }
48853
48854
48855 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48856 PyObject *resultobj = 0;
48857 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48858 wxSize *arg2 = 0 ;
48859 void *argp1 = 0 ;
48860 int res1 = 0 ;
48861 wxSize temp2 ;
48862 PyObject * obj0 = 0 ;
48863 PyObject * obj1 = 0 ;
48864 char * kwnames[] = {
48865 (char *) "self",(char *) "size", NULL
48866 };
48867
48868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48870 if (!SWIG_IsOK(res1)) {
48871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48872 }
48873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48874 {
48875 arg2 = &temp2;
48876 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48877 }
48878 {
48879 PyThreadState* __tstate = wxPyBeginAllowThreads();
48880 (arg1)->SetRatio((wxSize const &)*arg2);
48881 wxPyEndAllowThreads(__tstate);
48882 if (PyErr_Occurred()) SWIG_fail;
48883 }
48884 resultobj = SWIG_Py_Void();
48885 return resultobj;
48886 fail:
48887 return NULL;
48888 }
48889
48890
48891 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48892 PyObject *resultobj = 0;
48893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48894 float arg2 ;
48895 void *argp1 = 0 ;
48896 int res1 = 0 ;
48897 float val2 ;
48898 int ecode2 = 0 ;
48899 PyObject * obj0 = 0 ;
48900 PyObject * obj1 = 0 ;
48901 char * kwnames[] = {
48902 (char *) "self",(char *) "ratio", NULL
48903 };
48904
48905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48907 if (!SWIG_IsOK(res1)) {
48908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48909 }
48910 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48911 ecode2 = SWIG_AsVal_float(obj1, &val2);
48912 if (!SWIG_IsOK(ecode2)) {
48913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48914 }
48915 arg2 = static_cast< float >(val2);
48916 {
48917 PyThreadState* __tstate = wxPyBeginAllowThreads();
48918 (arg1)->SetRatio(arg2);
48919 wxPyEndAllowThreads(__tstate);
48920 if (PyErr_Occurred()) SWIG_fail;
48921 }
48922 resultobj = SWIG_Py_Void();
48923 return resultobj;
48924 fail:
48925 return NULL;
48926 }
48927
48928
48929 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48930 PyObject *resultobj = 0;
48931 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48932 float result;
48933 void *argp1 = 0 ;
48934 int res1 = 0 ;
48935 PyObject *swig_obj[1] ;
48936
48937 if (!args) SWIG_fail;
48938 swig_obj[0] = args;
48939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48940 if (!SWIG_IsOK(res1)) {
48941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48942 }
48943 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48944 {
48945 PyThreadState* __tstate = wxPyBeginAllowThreads();
48946 result = (float)(arg1)->GetRatio();
48947 wxPyEndAllowThreads(__tstate);
48948 if (PyErr_Occurred()) SWIG_fail;
48949 }
48950 resultobj = SWIG_From_float(static_cast< float >(result));
48951 return resultobj;
48952 fail:
48953 return NULL;
48954 }
48955
48956
48957 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48958 PyObject *resultobj = 0;
48959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48960 wxRect result;
48961 void *argp1 = 0 ;
48962 int res1 = 0 ;
48963 PyObject *swig_obj[1] ;
48964
48965 if (!args) SWIG_fail;
48966 swig_obj[0] = args;
48967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48968 if (!SWIG_IsOK(res1)) {
48969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48970 }
48971 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48972 {
48973 PyThreadState* __tstate = wxPyBeginAllowThreads();
48974 result = (arg1)->GetRect();
48975 wxPyEndAllowThreads(__tstate);
48976 if (PyErr_Occurred()) SWIG_fail;
48977 }
48978 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
48979 return resultobj;
48980 fail:
48981 return NULL;
48982 }
48983
48984
48985 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48986 PyObject *resultobj = 0;
48987 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48988 bool result;
48989 void *argp1 = 0 ;
48990 int res1 = 0 ;
48991 PyObject *swig_obj[1] ;
48992
48993 if (!args) SWIG_fail;
48994 swig_obj[0] = args;
48995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48996 if (!SWIG_IsOK(res1)) {
48997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48998 }
48999 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49000 {
49001 PyThreadState* __tstate = wxPyBeginAllowThreads();
49002 result = (bool)(arg1)->IsWindow();
49003 wxPyEndAllowThreads(__tstate);
49004 if (PyErr_Occurred()) SWIG_fail;
49005 }
49006 {
49007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49008 }
49009 return resultobj;
49010 fail:
49011 return NULL;
49012 }
49013
49014
49015 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49016 PyObject *resultobj = 0;
49017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49018 bool result;
49019 void *argp1 = 0 ;
49020 int res1 = 0 ;
49021 PyObject *swig_obj[1] ;
49022
49023 if (!args) SWIG_fail;
49024 swig_obj[0] = args;
49025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49026 if (!SWIG_IsOK(res1)) {
49027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49028 }
49029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49030 {
49031 PyThreadState* __tstate = wxPyBeginAllowThreads();
49032 result = (bool)(arg1)->IsSizer();
49033 wxPyEndAllowThreads(__tstate);
49034 if (PyErr_Occurred()) SWIG_fail;
49035 }
49036 {
49037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49038 }
49039 return resultobj;
49040 fail:
49041 return NULL;
49042 }
49043
49044
49045 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49046 PyObject *resultobj = 0;
49047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49048 bool result;
49049 void *argp1 = 0 ;
49050 int res1 = 0 ;
49051 PyObject *swig_obj[1] ;
49052
49053 if (!args) SWIG_fail;
49054 swig_obj[0] = args;
49055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49056 if (!SWIG_IsOK(res1)) {
49057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49058 }
49059 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 result = (bool)(arg1)->IsSpacer();
49063 wxPyEndAllowThreads(__tstate);
49064 if (PyErr_Occurred()) SWIG_fail;
49065 }
49066 {
49067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49068 }
49069 return resultobj;
49070 fail:
49071 return NULL;
49072 }
49073
49074
49075 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49076 PyObject *resultobj = 0;
49077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49078 int arg2 ;
49079 void *argp1 = 0 ;
49080 int res1 = 0 ;
49081 int val2 ;
49082 int ecode2 = 0 ;
49083 PyObject * obj0 = 0 ;
49084 PyObject * obj1 = 0 ;
49085 char * kwnames[] = {
49086 (char *) "self",(char *) "proportion", NULL
49087 };
49088
49089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49091 if (!SWIG_IsOK(res1)) {
49092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49093 }
49094 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49095 ecode2 = SWIG_AsVal_int(obj1, &val2);
49096 if (!SWIG_IsOK(ecode2)) {
49097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49098 }
49099 arg2 = static_cast< int >(val2);
49100 {
49101 PyThreadState* __tstate = wxPyBeginAllowThreads();
49102 (arg1)->SetProportion(arg2);
49103 wxPyEndAllowThreads(__tstate);
49104 if (PyErr_Occurred()) SWIG_fail;
49105 }
49106 resultobj = SWIG_Py_Void();
49107 return resultobj;
49108 fail:
49109 return NULL;
49110 }
49111
49112
49113 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49114 PyObject *resultobj = 0;
49115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49116 int result;
49117 void *argp1 = 0 ;
49118 int res1 = 0 ;
49119 PyObject *swig_obj[1] ;
49120
49121 if (!args) SWIG_fail;
49122 swig_obj[0] = args;
49123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49124 if (!SWIG_IsOK(res1)) {
49125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49126 }
49127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 result = (int)(arg1)->GetProportion();
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 resultobj = SWIG_From_int(static_cast< int >(result));
49135 return resultobj;
49136 fail:
49137 return NULL;
49138 }
49139
49140
49141 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49142 PyObject *resultobj = 0;
49143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49144 int arg2 ;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 int val2 ;
49148 int ecode2 = 0 ;
49149 PyObject * obj0 = 0 ;
49150 PyObject * obj1 = 0 ;
49151 char * kwnames[] = {
49152 (char *) "self",(char *) "flag", NULL
49153 };
49154
49155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49157 if (!SWIG_IsOK(res1)) {
49158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49159 }
49160 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49161 ecode2 = SWIG_AsVal_int(obj1, &val2);
49162 if (!SWIG_IsOK(ecode2)) {
49163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49164 }
49165 arg2 = static_cast< int >(val2);
49166 {
49167 PyThreadState* __tstate = wxPyBeginAllowThreads();
49168 (arg1)->SetFlag(arg2);
49169 wxPyEndAllowThreads(__tstate);
49170 if (PyErr_Occurred()) SWIG_fail;
49171 }
49172 resultobj = SWIG_Py_Void();
49173 return resultobj;
49174 fail:
49175 return NULL;
49176 }
49177
49178
49179 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49180 PyObject *resultobj = 0;
49181 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49182 int result;
49183 void *argp1 = 0 ;
49184 int res1 = 0 ;
49185 PyObject *swig_obj[1] ;
49186
49187 if (!args) SWIG_fail;
49188 swig_obj[0] = args;
49189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49190 if (!SWIG_IsOK(res1)) {
49191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49192 }
49193 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49194 {
49195 PyThreadState* __tstate = wxPyBeginAllowThreads();
49196 result = (int)(arg1)->GetFlag();
49197 wxPyEndAllowThreads(__tstate);
49198 if (PyErr_Occurred()) SWIG_fail;
49199 }
49200 resultobj = SWIG_From_int(static_cast< int >(result));
49201 return resultobj;
49202 fail:
49203 return NULL;
49204 }
49205
49206
49207 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49208 PyObject *resultobj = 0;
49209 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49210 int arg2 ;
49211 void *argp1 = 0 ;
49212 int res1 = 0 ;
49213 int val2 ;
49214 int ecode2 = 0 ;
49215 PyObject * obj0 = 0 ;
49216 PyObject * obj1 = 0 ;
49217 char * kwnames[] = {
49218 (char *) "self",(char *) "border", NULL
49219 };
49220
49221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49223 if (!SWIG_IsOK(res1)) {
49224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49225 }
49226 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49227 ecode2 = SWIG_AsVal_int(obj1, &val2);
49228 if (!SWIG_IsOK(ecode2)) {
49229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49230 }
49231 arg2 = static_cast< int >(val2);
49232 {
49233 PyThreadState* __tstate = wxPyBeginAllowThreads();
49234 (arg1)->SetBorder(arg2);
49235 wxPyEndAllowThreads(__tstate);
49236 if (PyErr_Occurred()) SWIG_fail;
49237 }
49238 resultobj = SWIG_Py_Void();
49239 return resultobj;
49240 fail:
49241 return NULL;
49242 }
49243
49244
49245 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49246 PyObject *resultobj = 0;
49247 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49248 int result;
49249 void *argp1 = 0 ;
49250 int res1 = 0 ;
49251 PyObject *swig_obj[1] ;
49252
49253 if (!args) SWIG_fail;
49254 swig_obj[0] = args;
49255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49256 if (!SWIG_IsOK(res1)) {
49257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49258 }
49259 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49260 {
49261 PyThreadState* __tstate = wxPyBeginAllowThreads();
49262 result = (int)(arg1)->GetBorder();
49263 wxPyEndAllowThreads(__tstate);
49264 if (PyErr_Occurred()) SWIG_fail;
49265 }
49266 resultobj = SWIG_From_int(static_cast< int >(result));
49267 return resultobj;
49268 fail:
49269 return NULL;
49270 }
49271
49272
49273 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49274 PyObject *resultobj = 0;
49275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49276 wxWindow *result = 0 ;
49277 void *argp1 = 0 ;
49278 int res1 = 0 ;
49279 PyObject *swig_obj[1] ;
49280
49281 if (!args) SWIG_fail;
49282 swig_obj[0] = args;
49283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49284 if (!SWIG_IsOK(res1)) {
49285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49286 }
49287 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49288 {
49289 PyThreadState* __tstate = wxPyBeginAllowThreads();
49290 result = (wxWindow *)(arg1)->GetWindow();
49291 wxPyEndAllowThreads(__tstate);
49292 if (PyErr_Occurred()) SWIG_fail;
49293 }
49294 {
49295 resultobj = wxPyMake_wxObject(result, 0);
49296 }
49297 return resultobj;
49298 fail:
49299 return NULL;
49300 }
49301
49302
49303 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49304 PyObject *resultobj = 0;
49305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49306 wxWindow *arg2 = (wxWindow *) 0 ;
49307 void *argp1 = 0 ;
49308 int res1 = 0 ;
49309 void *argp2 = 0 ;
49310 int res2 = 0 ;
49311 PyObject * obj0 = 0 ;
49312 PyObject * obj1 = 0 ;
49313 char * kwnames[] = {
49314 (char *) "self",(char *) "window", NULL
49315 };
49316
49317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49319 if (!SWIG_IsOK(res1)) {
49320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49321 }
49322 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49324 if (!SWIG_IsOK(res2)) {
49325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49326 }
49327 arg2 = reinterpret_cast< wxWindow * >(argp2);
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 (arg1)->SetWindow(arg2);
49331 wxPyEndAllowThreads(__tstate);
49332 if (PyErr_Occurred()) SWIG_fail;
49333 }
49334 resultobj = SWIG_Py_Void();
49335 return resultobj;
49336 fail:
49337 return NULL;
49338 }
49339
49340
49341 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49342 PyObject *resultobj = 0;
49343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49344 wxSizer *result = 0 ;
49345 void *argp1 = 0 ;
49346 int res1 = 0 ;
49347 PyObject *swig_obj[1] ;
49348
49349 if (!args) SWIG_fail;
49350 swig_obj[0] = args;
49351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49352 if (!SWIG_IsOK(res1)) {
49353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49354 }
49355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (wxSizer *)(arg1)->GetSizer();
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 {
49363 resultobj = wxPyMake_wxObject(result, (bool)0);
49364 }
49365 return resultobj;
49366 fail:
49367 return NULL;
49368 }
49369
49370
49371 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49372 PyObject *resultobj = 0;
49373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49374 wxSizer *arg2 = (wxSizer *) 0 ;
49375 void *argp1 = 0 ;
49376 int res1 = 0 ;
49377 int res2 = 0 ;
49378 PyObject * obj0 = 0 ;
49379 PyObject * obj1 = 0 ;
49380 char * kwnames[] = {
49381 (char *) "self",(char *) "sizer", NULL
49382 };
49383
49384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49386 if (!SWIG_IsOK(res1)) {
49387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49388 }
49389 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49390 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49391 if (!SWIG_IsOK(res2)) {
49392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49393 }
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 (arg1)->SetSizer(arg2);
49397 wxPyEndAllowThreads(__tstate);
49398 if (PyErr_Occurred()) SWIG_fail;
49399 }
49400 resultobj = SWIG_Py_Void();
49401 return resultobj;
49402 fail:
49403 return NULL;
49404 }
49405
49406
49407 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49408 PyObject *resultobj = 0;
49409 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49410 wxSize result;
49411 void *argp1 = 0 ;
49412 int res1 = 0 ;
49413 PyObject *swig_obj[1] ;
49414
49415 if (!args) SWIG_fail;
49416 swig_obj[0] = args;
49417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49418 if (!SWIG_IsOK(res1)) {
49419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49420 }
49421 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49422 {
49423 PyThreadState* __tstate = wxPyBeginAllowThreads();
49424 result = (arg1)->GetSpacer();
49425 wxPyEndAllowThreads(__tstate);
49426 if (PyErr_Occurred()) SWIG_fail;
49427 }
49428 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49429 return resultobj;
49430 fail:
49431 return NULL;
49432 }
49433
49434
49435 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49436 PyObject *resultobj = 0;
49437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49438 wxSize *arg2 = 0 ;
49439 void *argp1 = 0 ;
49440 int res1 = 0 ;
49441 wxSize temp2 ;
49442 PyObject * obj0 = 0 ;
49443 PyObject * obj1 = 0 ;
49444 char * kwnames[] = {
49445 (char *) "self",(char *) "size", NULL
49446 };
49447
49448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49450 if (!SWIG_IsOK(res1)) {
49451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49452 }
49453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49454 {
49455 arg2 = &temp2;
49456 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49457 }
49458 {
49459 PyThreadState* __tstate = wxPyBeginAllowThreads();
49460 (arg1)->SetSpacer((wxSize const &)*arg2);
49461 wxPyEndAllowThreads(__tstate);
49462 if (PyErr_Occurred()) SWIG_fail;
49463 }
49464 resultobj = SWIG_Py_Void();
49465 return resultobj;
49466 fail:
49467 return NULL;
49468 }
49469
49470
49471 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49472 PyObject *resultobj = 0;
49473 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49474 bool arg2 ;
49475 void *argp1 = 0 ;
49476 int res1 = 0 ;
49477 bool val2 ;
49478 int ecode2 = 0 ;
49479 PyObject * obj0 = 0 ;
49480 PyObject * obj1 = 0 ;
49481 char * kwnames[] = {
49482 (char *) "self",(char *) "show", NULL
49483 };
49484
49485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49487 if (!SWIG_IsOK(res1)) {
49488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49489 }
49490 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49492 if (!SWIG_IsOK(ecode2)) {
49493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49494 }
49495 arg2 = static_cast< bool >(val2);
49496 {
49497 PyThreadState* __tstate = wxPyBeginAllowThreads();
49498 (arg1)->Show(arg2);
49499 wxPyEndAllowThreads(__tstate);
49500 if (PyErr_Occurred()) SWIG_fail;
49501 }
49502 resultobj = SWIG_Py_Void();
49503 return resultobj;
49504 fail:
49505 return NULL;
49506 }
49507
49508
49509 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49510 PyObject *resultobj = 0;
49511 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49512 bool result;
49513 void *argp1 = 0 ;
49514 int res1 = 0 ;
49515 PyObject *swig_obj[1] ;
49516
49517 if (!args) SWIG_fail;
49518 swig_obj[0] = args;
49519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49520 if (!SWIG_IsOK(res1)) {
49521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49522 }
49523 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49524 {
49525 PyThreadState* __tstate = wxPyBeginAllowThreads();
49526 result = (bool)(arg1)->IsShown();
49527 wxPyEndAllowThreads(__tstate);
49528 if (PyErr_Occurred()) SWIG_fail;
49529 }
49530 {
49531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49532 }
49533 return resultobj;
49534 fail:
49535 return NULL;
49536 }
49537
49538
49539 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49540 PyObject *resultobj = 0;
49541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49542 wxPoint result;
49543 void *argp1 = 0 ;
49544 int res1 = 0 ;
49545 PyObject *swig_obj[1] ;
49546
49547 if (!args) SWIG_fail;
49548 swig_obj[0] = args;
49549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49550 if (!SWIG_IsOK(res1)) {
49551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49552 }
49553 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49554 {
49555 PyThreadState* __tstate = wxPyBeginAllowThreads();
49556 result = (arg1)->GetPosition();
49557 wxPyEndAllowThreads(__tstate);
49558 if (PyErr_Occurred()) SWIG_fail;
49559 }
49560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49561 return resultobj;
49562 fail:
49563 return NULL;
49564 }
49565
49566
49567 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49568 PyObject *resultobj = 0;
49569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49570 PyObject *result = 0 ;
49571 void *argp1 = 0 ;
49572 int res1 = 0 ;
49573 PyObject *swig_obj[1] ;
49574
49575 if (!args) SWIG_fail;
49576 swig_obj[0] = args;
49577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49578 if (!SWIG_IsOK(res1)) {
49579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49580 }
49581 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49582 {
49583 PyThreadState* __tstate = wxPyBeginAllowThreads();
49584 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49585 wxPyEndAllowThreads(__tstate);
49586 if (PyErr_Occurred()) SWIG_fail;
49587 }
49588 resultobj = result;
49589 return resultobj;
49590 fail:
49591 return NULL;
49592 }
49593
49594
49595 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49596 PyObject *resultobj = 0;
49597 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49598 PyObject *arg2 = (PyObject *) 0 ;
49599 void *argp1 = 0 ;
49600 int res1 = 0 ;
49601 PyObject * obj0 = 0 ;
49602 PyObject * obj1 = 0 ;
49603 char * kwnames[] = {
49604 (char *) "self",(char *) "userData", NULL
49605 };
49606
49607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49609 if (!SWIG_IsOK(res1)) {
49610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49611 }
49612 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49613 arg2 = obj1;
49614 {
49615 PyThreadState* __tstate = wxPyBeginAllowThreads();
49616 wxSizerItem_SetUserData(arg1,arg2);
49617 wxPyEndAllowThreads(__tstate);
49618 if (PyErr_Occurred()) SWIG_fail;
49619 }
49620 resultobj = SWIG_Py_Void();
49621 return resultobj;
49622 fail:
49623 return NULL;
49624 }
49625
49626
49627 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49628 PyObject *obj;
49629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49630 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49631 return SWIG_Py_Void();
49632 }
49633
49634 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49635 return SWIG_Python_InitShadowInstance(args);
49636 }
49637
49638 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49639 PyObject *resultobj = 0;
49640 wxSizer *arg1 = (wxSizer *) 0 ;
49641 void *argp1 = 0 ;
49642 int res1 = 0 ;
49643 PyObject *swig_obj[1] ;
49644
49645 if (!args) SWIG_fail;
49646 swig_obj[0] = args;
49647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49648 if (!SWIG_IsOK(res1)) {
49649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49650 }
49651 arg1 = reinterpret_cast< wxSizer * >(argp1);
49652 {
49653 PyThreadState* __tstate = wxPyBeginAllowThreads();
49654 delete arg1;
49655
49656 wxPyEndAllowThreads(__tstate);
49657 if (PyErr_Occurred()) SWIG_fail;
49658 }
49659 resultobj = SWIG_Py_Void();
49660 return resultobj;
49661 fail:
49662 return NULL;
49663 }
49664
49665
49666 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49667 PyObject *resultobj = 0;
49668 wxSizer *arg1 = (wxSizer *) 0 ;
49669 PyObject *arg2 = (PyObject *) 0 ;
49670 void *argp1 = 0 ;
49671 int res1 = 0 ;
49672 PyObject * obj0 = 0 ;
49673 PyObject * obj1 = 0 ;
49674 char * kwnames[] = {
49675 (char *) "self",(char *) "_self", NULL
49676 };
49677
49678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49680 if (!SWIG_IsOK(res1)) {
49681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49682 }
49683 arg1 = reinterpret_cast< wxSizer * >(argp1);
49684 arg2 = obj1;
49685 {
49686 PyThreadState* __tstate = wxPyBeginAllowThreads();
49687 wxSizer__setOORInfo(arg1,arg2);
49688 wxPyEndAllowThreads(__tstate);
49689 if (PyErr_Occurred()) SWIG_fail;
49690 }
49691 resultobj = SWIG_Py_Void();
49692 return resultobj;
49693 fail:
49694 return NULL;
49695 }
49696
49697
49698 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49699 PyObject *resultobj = 0;
49700 wxSizer *arg1 = (wxSizer *) 0 ;
49701 PyObject *arg2 = (PyObject *) 0 ;
49702 int arg3 = (int) 0 ;
49703 int arg4 = (int) 0 ;
49704 int arg5 = (int) 0 ;
49705 PyObject *arg6 = (PyObject *) NULL ;
49706 wxSizerItem *result = 0 ;
49707 void *argp1 = 0 ;
49708 int res1 = 0 ;
49709 int val3 ;
49710 int ecode3 = 0 ;
49711 int val4 ;
49712 int ecode4 = 0 ;
49713 int val5 ;
49714 int ecode5 = 0 ;
49715 PyObject * obj0 = 0 ;
49716 PyObject * obj1 = 0 ;
49717 PyObject * obj2 = 0 ;
49718 PyObject * obj3 = 0 ;
49719 PyObject * obj4 = 0 ;
49720 PyObject * obj5 = 0 ;
49721 char * kwnames[] = {
49722 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49723 };
49724
49725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49727 if (!SWIG_IsOK(res1)) {
49728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49729 }
49730 arg1 = reinterpret_cast< wxSizer * >(argp1);
49731 arg2 = obj1;
49732 if (obj2) {
49733 ecode3 = SWIG_AsVal_int(obj2, &val3);
49734 if (!SWIG_IsOK(ecode3)) {
49735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49736 }
49737 arg3 = static_cast< int >(val3);
49738 }
49739 if (obj3) {
49740 ecode4 = SWIG_AsVal_int(obj3, &val4);
49741 if (!SWIG_IsOK(ecode4)) {
49742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49743 }
49744 arg4 = static_cast< int >(val4);
49745 }
49746 if (obj4) {
49747 ecode5 = SWIG_AsVal_int(obj4, &val5);
49748 if (!SWIG_IsOK(ecode5)) {
49749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49750 }
49751 arg5 = static_cast< int >(val5);
49752 }
49753 if (obj5) {
49754 arg6 = obj5;
49755 }
49756 {
49757 PyThreadState* __tstate = wxPyBeginAllowThreads();
49758 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49759 wxPyEndAllowThreads(__tstate);
49760 if (PyErr_Occurred()) SWIG_fail;
49761 }
49762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49763 return resultobj;
49764 fail:
49765 return NULL;
49766 }
49767
49768
49769 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49770 PyObject *resultobj = 0;
49771 wxSizer *arg1 = (wxSizer *) 0 ;
49772 int arg2 ;
49773 PyObject *arg3 = (PyObject *) 0 ;
49774 int arg4 = (int) 0 ;
49775 int arg5 = (int) 0 ;
49776 int arg6 = (int) 0 ;
49777 PyObject *arg7 = (PyObject *) NULL ;
49778 wxSizerItem *result = 0 ;
49779 void *argp1 = 0 ;
49780 int res1 = 0 ;
49781 int val2 ;
49782 int ecode2 = 0 ;
49783 int val4 ;
49784 int ecode4 = 0 ;
49785 int val5 ;
49786 int ecode5 = 0 ;
49787 int val6 ;
49788 int ecode6 = 0 ;
49789 PyObject * obj0 = 0 ;
49790 PyObject * obj1 = 0 ;
49791 PyObject * obj2 = 0 ;
49792 PyObject * obj3 = 0 ;
49793 PyObject * obj4 = 0 ;
49794 PyObject * obj5 = 0 ;
49795 PyObject * obj6 = 0 ;
49796 char * kwnames[] = {
49797 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49798 };
49799
49800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49802 if (!SWIG_IsOK(res1)) {
49803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49804 }
49805 arg1 = reinterpret_cast< wxSizer * >(argp1);
49806 ecode2 = SWIG_AsVal_int(obj1, &val2);
49807 if (!SWIG_IsOK(ecode2)) {
49808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49809 }
49810 arg2 = static_cast< int >(val2);
49811 arg3 = obj2;
49812 if (obj3) {
49813 ecode4 = SWIG_AsVal_int(obj3, &val4);
49814 if (!SWIG_IsOK(ecode4)) {
49815 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49816 }
49817 arg4 = static_cast< int >(val4);
49818 }
49819 if (obj4) {
49820 ecode5 = SWIG_AsVal_int(obj4, &val5);
49821 if (!SWIG_IsOK(ecode5)) {
49822 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49823 }
49824 arg5 = static_cast< int >(val5);
49825 }
49826 if (obj5) {
49827 ecode6 = SWIG_AsVal_int(obj5, &val6);
49828 if (!SWIG_IsOK(ecode6)) {
49829 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49830 }
49831 arg6 = static_cast< int >(val6);
49832 }
49833 if (obj6) {
49834 arg7 = obj6;
49835 }
49836 {
49837 PyThreadState* __tstate = wxPyBeginAllowThreads();
49838 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49839 wxPyEndAllowThreads(__tstate);
49840 if (PyErr_Occurred()) SWIG_fail;
49841 }
49842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49843 return resultobj;
49844 fail:
49845 return NULL;
49846 }
49847
49848
49849 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49850 PyObject *resultobj = 0;
49851 wxSizer *arg1 = (wxSizer *) 0 ;
49852 PyObject *arg2 = (PyObject *) 0 ;
49853 int arg3 = (int) 0 ;
49854 int arg4 = (int) 0 ;
49855 int arg5 = (int) 0 ;
49856 PyObject *arg6 = (PyObject *) NULL ;
49857 wxSizerItem *result = 0 ;
49858 void *argp1 = 0 ;
49859 int res1 = 0 ;
49860 int val3 ;
49861 int ecode3 = 0 ;
49862 int val4 ;
49863 int ecode4 = 0 ;
49864 int val5 ;
49865 int ecode5 = 0 ;
49866 PyObject * obj0 = 0 ;
49867 PyObject * obj1 = 0 ;
49868 PyObject * obj2 = 0 ;
49869 PyObject * obj3 = 0 ;
49870 PyObject * obj4 = 0 ;
49871 PyObject * obj5 = 0 ;
49872 char * kwnames[] = {
49873 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49874 };
49875
49876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49878 if (!SWIG_IsOK(res1)) {
49879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49880 }
49881 arg1 = reinterpret_cast< wxSizer * >(argp1);
49882 arg2 = obj1;
49883 if (obj2) {
49884 ecode3 = SWIG_AsVal_int(obj2, &val3);
49885 if (!SWIG_IsOK(ecode3)) {
49886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49887 }
49888 arg3 = static_cast< int >(val3);
49889 }
49890 if (obj3) {
49891 ecode4 = SWIG_AsVal_int(obj3, &val4);
49892 if (!SWIG_IsOK(ecode4)) {
49893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49894 }
49895 arg4 = static_cast< int >(val4);
49896 }
49897 if (obj4) {
49898 ecode5 = SWIG_AsVal_int(obj4, &val5);
49899 if (!SWIG_IsOK(ecode5)) {
49900 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49901 }
49902 arg5 = static_cast< int >(val5);
49903 }
49904 if (obj5) {
49905 arg6 = obj5;
49906 }
49907 {
49908 PyThreadState* __tstate = wxPyBeginAllowThreads();
49909 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49910 wxPyEndAllowThreads(__tstate);
49911 if (PyErr_Occurred()) SWIG_fail;
49912 }
49913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49914 return resultobj;
49915 fail:
49916 return NULL;
49917 }
49918
49919
49920 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49921 PyObject *resultobj = 0;
49922 wxSizer *arg1 = (wxSizer *) 0 ;
49923 PyObject *arg2 = (PyObject *) 0 ;
49924 bool result;
49925 void *argp1 = 0 ;
49926 int res1 = 0 ;
49927 PyObject * obj0 = 0 ;
49928 PyObject * obj1 = 0 ;
49929 char * kwnames[] = {
49930 (char *) "self",(char *) "item", NULL
49931 };
49932
49933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49935 if (!SWIG_IsOK(res1)) {
49936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49937 }
49938 arg1 = reinterpret_cast< wxSizer * >(argp1);
49939 arg2 = obj1;
49940 {
49941 PyThreadState* __tstate = wxPyBeginAllowThreads();
49942 result = (bool)wxSizer_Remove(arg1,arg2);
49943 wxPyEndAllowThreads(__tstate);
49944 if (PyErr_Occurred()) SWIG_fail;
49945 }
49946 {
49947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49948 }
49949 return resultobj;
49950 fail:
49951 return NULL;
49952 }
49953
49954
49955 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49956 PyObject *resultobj = 0;
49957 wxSizer *arg1 = (wxSizer *) 0 ;
49958 PyObject *arg2 = (PyObject *) 0 ;
49959 bool result;
49960 void *argp1 = 0 ;
49961 int res1 = 0 ;
49962 PyObject * obj0 = 0 ;
49963 PyObject * obj1 = 0 ;
49964 char * kwnames[] = {
49965 (char *) "self",(char *) "item", NULL
49966 };
49967
49968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49970 if (!SWIG_IsOK(res1)) {
49971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
49972 }
49973 arg1 = reinterpret_cast< wxSizer * >(argp1);
49974 arg2 = obj1;
49975 {
49976 PyThreadState* __tstate = wxPyBeginAllowThreads();
49977 result = (bool)wxSizer_Detach(arg1,arg2);
49978 wxPyEndAllowThreads(__tstate);
49979 if (PyErr_Occurred()) SWIG_fail;
49980 }
49981 {
49982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49983 }
49984 return resultobj;
49985 fail:
49986 return NULL;
49987 }
49988
49989
49990 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49991 PyObject *resultobj = 0;
49992 wxSizer *arg1 = (wxSizer *) 0 ;
49993 PyObject *arg2 = (PyObject *) 0 ;
49994 wxSizerItem *result = 0 ;
49995 void *argp1 = 0 ;
49996 int res1 = 0 ;
49997 PyObject * obj0 = 0 ;
49998 PyObject * obj1 = 0 ;
49999 char * kwnames[] = {
50000 (char *) "self",(char *) "item", NULL
50001 };
50002
50003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50005 if (!SWIG_IsOK(res1)) {
50006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50007 }
50008 arg1 = reinterpret_cast< wxSizer * >(argp1);
50009 arg2 = obj1;
50010 {
50011 PyThreadState* __tstate = wxPyBeginAllowThreads();
50012 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50013 wxPyEndAllowThreads(__tstate);
50014 if (PyErr_Occurred()) SWIG_fail;
50015 }
50016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50017 return resultobj;
50018 fail:
50019 return NULL;
50020 }
50021
50022
50023 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50024 PyObject *resultobj = 0;
50025 wxSizer *arg1 = (wxSizer *) 0 ;
50026 PyObject *arg2 = (PyObject *) 0 ;
50027 wxSize *arg3 = 0 ;
50028 void *argp1 = 0 ;
50029 int res1 = 0 ;
50030 wxSize temp3 ;
50031 PyObject * obj0 = 0 ;
50032 PyObject * obj1 = 0 ;
50033 PyObject * obj2 = 0 ;
50034 char * kwnames[] = {
50035 (char *) "self",(char *) "item",(char *) "size", NULL
50036 };
50037
50038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50040 if (!SWIG_IsOK(res1)) {
50041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50042 }
50043 arg1 = reinterpret_cast< wxSizer * >(argp1);
50044 arg2 = obj1;
50045 {
50046 arg3 = &temp3;
50047 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50048 }
50049 {
50050 PyThreadState* __tstate = wxPyBeginAllowThreads();
50051 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50052 wxPyEndAllowThreads(__tstate);
50053 if (PyErr_Occurred()) SWIG_fail;
50054 }
50055 resultobj = SWIG_Py_Void();
50056 return resultobj;
50057 fail:
50058 return NULL;
50059 }
50060
50061
50062 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50063 PyObject *resultobj = 0;
50064 wxSizer *arg1 = (wxSizer *) 0 ;
50065 wxWindow *arg2 = (wxWindow *) 0 ;
50066 wxWindow *arg3 = (wxWindow *) 0 ;
50067 bool arg4 = (bool) false ;
50068 bool result;
50069 void *argp1 = 0 ;
50070 int res1 = 0 ;
50071 void *argp2 = 0 ;
50072 int res2 = 0 ;
50073 void *argp3 = 0 ;
50074 int res3 = 0 ;
50075 bool val4 ;
50076 int ecode4 = 0 ;
50077 PyObject * obj0 = 0 ;
50078 PyObject * obj1 = 0 ;
50079 PyObject * obj2 = 0 ;
50080 PyObject * obj3 = 0 ;
50081 char * kwnames[] = {
50082 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50083 };
50084
50085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50087 if (!SWIG_IsOK(res1)) {
50088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50089 }
50090 arg1 = reinterpret_cast< wxSizer * >(argp1);
50091 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50092 if (!SWIG_IsOK(res2)) {
50093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50094 }
50095 arg2 = reinterpret_cast< wxWindow * >(argp2);
50096 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50097 if (!SWIG_IsOK(res3)) {
50098 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50099 }
50100 arg3 = reinterpret_cast< wxWindow * >(argp3);
50101 if (obj3) {
50102 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50103 if (!SWIG_IsOK(ecode4)) {
50104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50105 }
50106 arg4 = static_cast< bool >(val4);
50107 }
50108 {
50109 PyThreadState* __tstate = wxPyBeginAllowThreads();
50110 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50111 wxPyEndAllowThreads(__tstate);
50112 if (PyErr_Occurred()) SWIG_fail;
50113 }
50114 {
50115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50116 }
50117 return resultobj;
50118 fail:
50119 return NULL;
50120 }
50121
50122
50123 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50124 PyObject *resultobj = 0;
50125 wxSizer *arg1 = (wxSizer *) 0 ;
50126 wxSizer *arg2 = (wxSizer *) 0 ;
50127 wxSizer *arg3 = (wxSizer *) 0 ;
50128 bool arg4 = (bool) false ;
50129 bool result;
50130 void *argp1 = 0 ;
50131 int res1 = 0 ;
50132 void *argp2 = 0 ;
50133 int res2 = 0 ;
50134 void *argp3 = 0 ;
50135 int res3 = 0 ;
50136 bool val4 ;
50137 int ecode4 = 0 ;
50138 PyObject * obj0 = 0 ;
50139 PyObject * obj1 = 0 ;
50140 PyObject * obj2 = 0 ;
50141 PyObject * obj3 = 0 ;
50142 char * kwnames[] = {
50143 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50144 };
50145
50146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50148 if (!SWIG_IsOK(res1)) {
50149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50150 }
50151 arg1 = reinterpret_cast< wxSizer * >(argp1);
50152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50153 if (!SWIG_IsOK(res2)) {
50154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50155 }
50156 arg2 = reinterpret_cast< wxSizer * >(argp2);
50157 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50158 if (!SWIG_IsOK(res3)) {
50159 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50160 }
50161 arg3 = reinterpret_cast< wxSizer * >(argp3);
50162 if (obj3) {
50163 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50164 if (!SWIG_IsOK(ecode4)) {
50165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50166 }
50167 arg4 = static_cast< bool >(val4);
50168 }
50169 {
50170 PyThreadState* __tstate = wxPyBeginAllowThreads();
50171 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50172 wxPyEndAllowThreads(__tstate);
50173 if (PyErr_Occurred()) SWIG_fail;
50174 }
50175 {
50176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50177 }
50178 return resultobj;
50179 fail:
50180 return NULL;
50181 }
50182
50183
50184 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50185 PyObject *resultobj = 0;
50186 wxSizer *arg1 = (wxSizer *) 0 ;
50187 size_t arg2 ;
50188 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50189 bool result;
50190 void *argp1 = 0 ;
50191 int res1 = 0 ;
50192 size_t val2 ;
50193 int ecode2 = 0 ;
50194 void *argp3 = 0 ;
50195 int res3 = 0 ;
50196 PyObject * obj0 = 0 ;
50197 PyObject * obj1 = 0 ;
50198 PyObject * obj2 = 0 ;
50199 char * kwnames[] = {
50200 (char *) "self",(char *) "index",(char *) "newitem", NULL
50201 };
50202
50203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50205 if (!SWIG_IsOK(res1)) {
50206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50207 }
50208 arg1 = reinterpret_cast< wxSizer * >(argp1);
50209 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50210 if (!SWIG_IsOK(ecode2)) {
50211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50212 }
50213 arg2 = static_cast< size_t >(val2);
50214 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50215 if (!SWIG_IsOK(res3)) {
50216 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50217 }
50218 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50219 {
50220 PyThreadState* __tstate = wxPyBeginAllowThreads();
50221 result = (bool)(arg1)->Replace(arg2,arg3);
50222 wxPyEndAllowThreads(__tstate);
50223 if (PyErr_Occurred()) SWIG_fail;
50224 }
50225 {
50226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50227 }
50228 return resultobj;
50229 fail:
50230 return NULL;
50231 }
50232
50233
50234 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50235 PyObject *resultobj = 0;
50236 wxSizer *arg1 = (wxSizer *) 0 ;
50237 wxWindow *arg2 = (wxWindow *) 0 ;
50238 void *argp1 = 0 ;
50239 int res1 = 0 ;
50240 void *argp2 = 0 ;
50241 int res2 = 0 ;
50242 PyObject * obj0 = 0 ;
50243 PyObject * obj1 = 0 ;
50244 char * kwnames[] = {
50245 (char *) "self",(char *) "window", NULL
50246 };
50247
50248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50250 if (!SWIG_IsOK(res1)) {
50251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50252 }
50253 arg1 = reinterpret_cast< wxSizer * >(argp1);
50254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50255 if (!SWIG_IsOK(res2)) {
50256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50257 }
50258 arg2 = reinterpret_cast< wxWindow * >(argp2);
50259 {
50260 PyThreadState* __tstate = wxPyBeginAllowThreads();
50261 (arg1)->SetContainingWindow(arg2);
50262 wxPyEndAllowThreads(__tstate);
50263 if (PyErr_Occurred()) SWIG_fail;
50264 }
50265 resultobj = SWIG_Py_Void();
50266 return resultobj;
50267 fail:
50268 return NULL;
50269 }
50270
50271
50272 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50273 PyObject *resultobj = 0;
50274 wxSizer *arg1 = (wxSizer *) 0 ;
50275 wxWindow *result = 0 ;
50276 void *argp1 = 0 ;
50277 int res1 = 0 ;
50278 PyObject *swig_obj[1] ;
50279
50280 if (!args) SWIG_fail;
50281 swig_obj[0] = args;
50282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50283 if (!SWIG_IsOK(res1)) {
50284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50285 }
50286 arg1 = reinterpret_cast< wxSizer * >(argp1);
50287 {
50288 PyThreadState* __tstate = wxPyBeginAllowThreads();
50289 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50290 wxPyEndAllowThreads(__tstate);
50291 if (PyErr_Occurred()) SWIG_fail;
50292 }
50293 {
50294 resultobj = wxPyMake_wxObject(result, 0);
50295 }
50296 return resultobj;
50297 fail:
50298 return NULL;
50299 }
50300
50301
50302 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50303 PyObject *resultobj = 0;
50304 wxSizer *arg1 = (wxSizer *) 0 ;
50305 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50306 wxSizerItem *result = 0 ;
50307 void *argp1 = 0 ;
50308 int res1 = 0 ;
50309 int res2 = 0 ;
50310 PyObject * obj0 = 0 ;
50311 PyObject * obj1 = 0 ;
50312 char * kwnames[] = {
50313 (char *) "self",(char *) "item", NULL
50314 };
50315
50316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50318 if (!SWIG_IsOK(res1)) {
50319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50320 }
50321 arg1 = reinterpret_cast< wxSizer * >(argp1);
50322 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50323 if (!SWIG_IsOK(res2)) {
50324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50325 }
50326 {
50327 PyThreadState* __tstate = wxPyBeginAllowThreads();
50328 result = (wxSizerItem *)(arg1)->Add(arg2);
50329 wxPyEndAllowThreads(__tstate);
50330 if (PyErr_Occurred()) SWIG_fail;
50331 }
50332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50333 return resultobj;
50334 fail:
50335 return NULL;
50336 }
50337
50338
50339 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50340 PyObject *resultobj = 0;
50341 wxSizer *arg1 = (wxSizer *) 0 ;
50342 size_t arg2 ;
50343 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50344 wxSizerItem *result = 0 ;
50345 void *argp1 = 0 ;
50346 int res1 = 0 ;
50347 size_t val2 ;
50348 int ecode2 = 0 ;
50349 int res3 = 0 ;
50350 PyObject * obj0 = 0 ;
50351 PyObject * obj1 = 0 ;
50352 PyObject * obj2 = 0 ;
50353 char * kwnames[] = {
50354 (char *) "self",(char *) "index",(char *) "item", NULL
50355 };
50356
50357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50359 if (!SWIG_IsOK(res1)) {
50360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50361 }
50362 arg1 = reinterpret_cast< wxSizer * >(argp1);
50363 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50364 if (!SWIG_IsOK(ecode2)) {
50365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50366 }
50367 arg2 = static_cast< size_t >(val2);
50368 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50369 if (!SWIG_IsOK(res3)) {
50370 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50371 }
50372 {
50373 PyThreadState* __tstate = wxPyBeginAllowThreads();
50374 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50375 wxPyEndAllowThreads(__tstate);
50376 if (PyErr_Occurred()) SWIG_fail;
50377 }
50378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50379 return resultobj;
50380 fail:
50381 return NULL;
50382 }
50383
50384
50385 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50386 PyObject *resultobj = 0;
50387 wxSizer *arg1 = (wxSizer *) 0 ;
50388 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50389 wxSizerItem *result = 0 ;
50390 void *argp1 = 0 ;
50391 int res1 = 0 ;
50392 int res2 = 0 ;
50393 PyObject * obj0 = 0 ;
50394 PyObject * obj1 = 0 ;
50395 char * kwnames[] = {
50396 (char *) "self",(char *) "item", NULL
50397 };
50398
50399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50401 if (!SWIG_IsOK(res1)) {
50402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50403 }
50404 arg1 = reinterpret_cast< wxSizer * >(argp1);
50405 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50406 if (!SWIG_IsOK(res2)) {
50407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50408 }
50409 {
50410 PyThreadState* __tstate = wxPyBeginAllowThreads();
50411 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50412 wxPyEndAllowThreads(__tstate);
50413 if (PyErr_Occurred()) SWIG_fail;
50414 }
50415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50416 return resultobj;
50417 fail:
50418 return NULL;
50419 }
50420
50421
50422 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50423 PyObject *resultobj = 0;
50424 wxSizer *arg1 = (wxSizer *) 0 ;
50425 int arg2 ;
50426 int arg3 ;
50427 int arg4 ;
50428 int arg5 ;
50429 void *argp1 = 0 ;
50430 int res1 = 0 ;
50431 int val2 ;
50432 int ecode2 = 0 ;
50433 int val3 ;
50434 int ecode3 = 0 ;
50435 int val4 ;
50436 int ecode4 = 0 ;
50437 int val5 ;
50438 int ecode5 = 0 ;
50439 PyObject * obj0 = 0 ;
50440 PyObject * obj1 = 0 ;
50441 PyObject * obj2 = 0 ;
50442 PyObject * obj3 = 0 ;
50443 PyObject * obj4 = 0 ;
50444 char * kwnames[] = {
50445 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50446 };
50447
50448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50450 if (!SWIG_IsOK(res1)) {
50451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50452 }
50453 arg1 = reinterpret_cast< wxSizer * >(argp1);
50454 ecode2 = SWIG_AsVal_int(obj1, &val2);
50455 if (!SWIG_IsOK(ecode2)) {
50456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50457 }
50458 arg2 = static_cast< int >(val2);
50459 ecode3 = SWIG_AsVal_int(obj2, &val3);
50460 if (!SWIG_IsOK(ecode3)) {
50461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50462 }
50463 arg3 = static_cast< int >(val3);
50464 ecode4 = SWIG_AsVal_int(obj3, &val4);
50465 if (!SWIG_IsOK(ecode4)) {
50466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50467 }
50468 arg4 = static_cast< int >(val4);
50469 ecode5 = SWIG_AsVal_int(obj4, &val5);
50470 if (!SWIG_IsOK(ecode5)) {
50471 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50472 }
50473 arg5 = static_cast< int >(val5);
50474 {
50475 PyThreadState* __tstate = wxPyBeginAllowThreads();
50476 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50477 wxPyEndAllowThreads(__tstate);
50478 if (PyErr_Occurred()) SWIG_fail;
50479 }
50480 resultobj = SWIG_Py_Void();
50481 return resultobj;
50482 fail:
50483 return NULL;
50484 }
50485
50486
50487 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50488 PyObject *resultobj = 0;
50489 wxSizer *arg1 = (wxSizer *) 0 ;
50490 wxSize *arg2 = 0 ;
50491 void *argp1 = 0 ;
50492 int res1 = 0 ;
50493 wxSize temp2 ;
50494 PyObject * obj0 = 0 ;
50495 PyObject * obj1 = 0 ;
50496 char * kwnames[] = {
50497 (char *) "self",(char *) "size", NULL
50498 };
50499
50500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50502 if (!SWIG_IsOK(res1)) {
50503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50504 }
50505 arg1 = reinterpret_cast< wxSizer * >(argp1);
50506 {
50507 arg2 = &temp2;
50508 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50509 }
50510 {
50511 PyThreadState* __tstate = wxPyBeginAllowThreads();
50512 (arg1)->SetMinSize((wxSize const &)*arg2);
50513 wxPyEndAllowThreads(__tstate);
50514 if (PyErr_Occurred()) SWIG_fail;
50515 }
50516 resultobj = SWIG_Py_Void();
50517 return resultobj;
50518 fail:
50519 return NULL;
50520 }
50521
50522
50523 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50524 PyObject *resultobj = 0;
50525 wxSizer *arg1 = (wxSizer *) 0 ;
50526 wxSize result;
50527 void *argp1 = 0 ;
50528 int res1 = 0 ;
50529 PyObject *swig_obj[1] ;
50530
50531 if (!args) SWIG_fail;
50532 swig_obj[0] = args;
50533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50534 if (!SWIG_IsOK(res1)) {
50535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50536 }
50537 arg1 = reinterpret_cast< wxSizer * >(argp1);
50538 {
50539 PyThreadState* __tstate = wxPyBeginAllowThreads();
50540 result = (arg1)->GetSize();
50541 wxPyEndAllowThreads(__tstate);
50542 if (PyErr_Occurred()) SWIG_fail;
50543 }
50544 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50552 PyObject *resultobj = 0;
50553 wxSizer *arg1 = (wxSizer *) 0 ;
50554 wxPoint result;
50555 void *argp1 = 0 ;
50556 int res1 = 0 ;
50557 PyObject *swig_obj[1] ;
50558
50559 if (!args) SWIG_fail;
50560 swig_obj[0] = args;
50561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50562 if (!SWIG_IsOK(res1)) {
50563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50564 }
50565 arg1 = reinterpret_cast< wxSizer * >(argp1);
50566 {
50567 PyThreadState* __tstate = wxPyBeginAllowThreads();
50568 result = (arg1)->GetPosition();
50569 wxPyEndAllowThreads(__tstate);
50570 if (PyErr_Occurred()) SWIG_fail;
50571 }
50572 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50573 return resultobj;
50574 fail:
50575 return NULL;
50576 }
50577
50578
50579 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50580 PyObject *resultobj = 0;
50581 wxSizer *arg1 = (wxSizer *) 0 ;
50582 wxSize result;
50583 void *argp1 = 0 ;
50584 int res1 = 0 ;
50585 PyObject *swig_obj[1] ;
50586
50587 if (!args) SWIG_fail;
50588 swig_obj[0] = args;
50589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50590 if (!SWIG_IsOK(res1)) {
50591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50592 }
50593 arg1 = reinterpret_cast< wxSizer * >(argp1);
50594 {
50595 PyThreadState* __tstate = wxPyBeginAllowThreads();
50596 result = (arg1)->GetMinSize();
50597 wxPyEndAllowThreads(__tstate);
50598 if (PyErr_Occurred()) SWIG_fail;
50599 }
50600 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50601 return resultobj;
50602 fail:
50603 return NULL;
50604 }
50605
50606
50607 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50608 PyObject *resultobj = 0;
50609 wxSizer *arg1 = (wxSizer *) 0 ;
50610 void *argp1 = 0 ;
50611 int res1 = 0 ;
50612 PyObject *swig_obj[1] ;
50613
50614 if (!args) SWIG_fail;
50615 swig_obj[0] = args;
50616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50617 if (!SWIG_IsOK(res1)) {
50618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50619 }
50620 arg1 = reinterpret_cast< wxSizer * >(argp1);
50621 {
50622 PyThreadState* __tstate = wxPyBeginAllowThreads();
50623 (arg1)->RecalcSizes();
50624 wxPyEndAllowThreads(__tstate);
50625 if (PyErr_Occurred()) SWIG_fail;
50626 }
50627 resultobj = SWIG_Py_Void();
50628 return resultobj;
50629 fail:
50630 return NULL;
50631 }
50632
50633
50634 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50635 PyObject *resultobj = 0;
50636 wxSizer *arg1 = (wxSizer *) 0 ;
50637 wxSize result;
50638 void *argp1 = 0 ;
50639 int res1 = 0 ;
50640 PyObject *swig_obj[1] ;
50641
50642 if (!args) SWIG_fail;
50643 swig_obj[0] = args;
50644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50645 if (!SWIG_IsOK(res1)) {
50646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50647 }
50648 arg1 = reinterpret_cast< wxSizer * >(argp1);
50649 {
50650 PyThreadState* __tstate = wxPyBeginAllowThreads();
50651 result = (arg1)->CalcMin();
50652 wxPyEndAllowThreads(__tstate);
50653 if (PyErr_Occurred()) SWIG_fail;
50654 }
50655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50656 return resultobj;
50657 fail:
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50663 PyObject *resultobj = 0;
50664 wxSizer *arg1 = (wxSizer *) 0 ;
50665 void *argp1 = 0 ;
50666 int res1 = 0 ;
50667 PyObject *swig_obj[1] ;
50668
50669 if (!args) SWIG_fail;
50670 swig_obj[0] = args;
50671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50672 if (!SWIG_IsOK(res1)) {
50673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50674 }
50675 arg1 = reinterpret_cast< wxSizer * >(argp1);
50676 {
50677 PyThreadState* __tstate = wxPyBeginAllowThreads();
50678 (arg1)->Layout();
50679 wxPyEndAllowThreads(__tstate);
50680 if (PyErr_Occurred()) SWIG_fail;
50681 }
50682 resultobj = SWIG_Py_Void();
50683 return resultobj;
50684 fail:
50685 return NULL;
50686 }
50687
50688
50689 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50690 PyObject *resultobj = 0;
50691 wxSizer *arg1 = (wxSizer *) 0 ;
50692 wxWindow *arg2 = (wxWindow *) 0 ;
50693 wxSize result;
50694 void *argp1 = 0 ;
50695 int res1 = 0 ;
50696 void *argp2 = 0 ;
50697 int res2 = 0 ;
50698 PyObject * obj0 = 0 ;
50699 PyObject * obj1 = 0 ;
50700 char * kwnames[] = {
50701 (char *) "self",(char *) "window", NULL
50702 };
50703
50704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50708 }
50709 arg1 = reinterpret_cast< wxSizer * >(argp1);
50710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50711 if (!SWIG_IsOK(res2)) {
50712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50713 }
50714 arg2 = reinterpret_cast< wxWindow * >(argp2);
50715 {
50716 PyThreadState* __tstate = wxPyBeginAllowThreads();
50717 result = (arg1)->Fit(arg2);
50718 wxPyEndAllowThreads(__tstate);
50719 if (PyErr_Occurred()) SWIG_fail;
50720 }
50721 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50722 return resultobj;
50723 fail:
50724 return NULL;
50725 }
50726
50727
50728 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50729 PyObject *resultobj = 0;
50730 wxSizer *arg1 = (wxSizer *) 0 ;
50731 wxWindow *arg2 = (wxWindow *) 0 ;
50732 void *argp1 = 0 ;
50733 int res1 = 0 ;
50734 void *argp2 = 0 ;
50735 int res2 = 0 ;
50736 PyObject * obj0 = 0 ;
50737 PyObject * obj1 = 0 ;
50738 char * kwnames[] = {
50739 (char *) "self",(char *) "window", NULL
50740 };
50741
50742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50744 if (!SWIG_IsOK(res1)) {
50745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50746 }
50747 arg1 = reinterpret_cast< wxSizer * >(argp1);
50748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50749 if (!SWIG_IsOK(res2)) {
50750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50751 }
50752 arg2 = reinterpret_cast< wxWindow * >(argp2);
50753 {
50754 PyThreadState* __tstate = wxPyBeginAllowThreads();
50755 (arg1)->FitInside(arg2);
50756 wxPyEndAllowThreads(__tstate);
50757 if (PyErr_Occurred()) SWIG_fail;
50758 }
50759 resultobj = SWIG_Py_Void();
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50767 PyObject *resultobj = 0;
50768 wxSizer *arg1 = (wxSizer *) 0 ;
50769 wxWindow *arg2 = (wxWindow *) 0 ;
50770 void *argp1 = 0 ;
50771 int res1 = 0 ;
50772 void *argp2 = 0 ;
50773 int res2 = 0 ;
50774 PyObject * obj0 = 0 ;
50775 PyObject * obj1 = 0 ;
50776 char * kwnames[] = {
50777 (char *) "self",(char *) "window", NULL
50778 };
50779
50780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50782 if (!SWIG_IsOK(res1)) {
50783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50784 }
50785 arg1 = reinterpret_cast< wxSizer * >(argp1);
50786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50787 if (!SWIG_IsOK(res2)) {
50788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50789 }
50790 arg2 = reinterpret_cast< wxWindow * >(argp2);
50791 {
50792 PyThreadState* __tstate = wxPyBeginAllowThreads();
50793 (arg1)->SetSizeHints(arg2);
50794 wxPyEndAllowThreads(__tstate);
50795 if (PyErr_Occurred()) SWIG_fail;
50796 }
50797 resultobj = SWIG_Py_Void();
50798 return resultobj;
50799 fail:
50800 return NULL;
50801 }
50802
50803
50804 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50805 PyObject *resultobj = 0;
50806 wxSizer *arg1 = (wxSizer *) 0 ;
50807 wxWindow *arg2 = (wxWindow *) 0 ;
50808 void *argp1 = 0 ;
50809 int res1 = 0 ;
50810 void *argp2 = 0 ;
50811 int res2 = 0 ;
50812 PyObject * obj0 = 0 ;
50813 PyObject * obj1 = 0 ;
50814 char * kwnames[] = {
50815 (char *) "self",(char *) "window", NULL
50816 };
50817
50818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50820 if (!SWIG_IsOK(res1)) {
50821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50822 }
50823 arg1 = reinterpret_cast< wxSizer * >(argp1);
50824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50825 if (!SWIG_IsOK(res2)) {
50826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50827 }
50828 arg2 = reinterpret_cast< wxWindow * >(argp2);
50829 {
50830 PyThreadState* __tstate = wxPyBeginAllowThreads();
50831 (arg1)->SetVirtualSizeHints(arg2);
50832 wxPyEndAllowThreads(__tstate);
50833 if (PyErr_Occurred()) SWIG_fail;
50834 }
50835 resultobj = SWIG_Py_Void();
50836 return resultobj;
50837 fail:
50838 return NULL;
50839 }
50840
50841
50842 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50843 PyObject *resultobj = 0;
50844 wxSizer *arg1 = (wxSizer *) 0 ;
50845 bool arg2 = (bool) false ;
50846 void *argp1 = 0 ;
50847 int res1 = 0 ;
50848 bool val2 ;
50849 int ecode2 = 0 ;
50850 PyObject * obj0 = 0 ;
50851 PyObject * obj1 = 0 ;
50852 char * kwnames[] = {
50853 (char *) "self",(char *) "deleteWindows", NULL
50854 };
50855
50856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50858 if (!SWIG_IsOK(res1)) {
50859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50860 }
50861 arg1 = reinterpret_cast< wxSizer * >(argp1);
50862 if (obj1) {
50863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50864 if (!SWIG_IsOK(ecode2)) {
50865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50866 }
50867 arg2 = static_cast< bool >(val2);
50868 }
50869 {
50870 PyThreadState* __tstate = wxPyBeginAllowThreads();
50871 (arg1)->Clear(arg2);
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 resultobj = SWIG_Py_Void();
50876 return resultobj;
50877 fail:
50878 return NULL;
50879 }
50880
50881
50882 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50883 PyObject *resultobj = 0;
50884 wxSizer *arg1 = (wxSizer *) 0 ;
50885 void *argp1 = 0 ;
50886 int res1 = 0 ;
50887 PyObject *swig_obj[1] ;
50888
50889 if (!args) SWIG_fail;
50890 swig_obj[0] = args;
50891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50892 if (!SWIG_IsOK(res1)) {
50893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50894 }
50895 arg1 = reinterpret_cast< wxSizer * >(argp1);
50896 {
50897 PyThreadState* __tstate = wxPyBeginAllowThreads();
50898 (arg1)->DeleteWindows();
50899 wxPyEndAllowThreads(__tstate);
50900 if (PyErr_Occurred()) SWIG_fail;
50901 }
50902 resultobj = SWIG_Py_Void();
50903 return resultobj;
50904 fail:
50905 return NULL;
50906 }
50907
50908
50909 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50910 PyObject *resultobj = 0;
50911 wxSizer *arg1 = (wxSizer *) 0 ;
50912 PyObject *result = 0 ;
50913 void *argp1 = 0 ;
50914 int res1 = 0 ;
50915 PyObject *swig_obj[1] ;
50916
50917 if (!args) SWIG_fail;
50918 swig_obj[0] = args;
50919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50920 if (!SWIG_IsOK(res1)) {
50921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50922 }
50923 arg1 = reinterpret_cast< wxSizer * >(argp1);
50924 {
50925 PyThreadState* __tstate = wxPyBeginAllowThreads();
50926 result = (PyObject *)wxSizer_GetChildren(arg1);
50927 wxPyEndAllowThreads(__tstate);
50928 if (PyErr_Occurred()) SWIG_fail;
50929 }
50930 resultobj = result;
50931 return resultobj;
50932 fail:
50933 return NULL;
50934 }
50935
50936
50937 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50938 PyObject *resultobj = 0;
50939 wxSizer *arg1 = (wxSizer *) 0 ;
50940 PyObject *arg2 = (PyObject *) 0 ;
50941 bool arg3 = (bool) true ;
50942 bool arg4 = (bool) false ;
50943 bool result;
50944 void *argp1 = 0 ;
50945 int res1 = 0 ;
50946 bool val3 ;
50947 int ecode3 = 0 ;
50948 bool val4 ;
50949 int ecode4 = 0 ;
50950 PyObject * obj0 = 0 ;
50951 PyObject * obj1 = 0 ;
50952 PyObject * obj2 = 0 ;
50953 PyObject * obj3 = 0 ;
50954 char * kwnames[] = {
50955 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50956 };
50957
50958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50960 if (!SWIG_IsOK(res1)) {
50961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50962 }
50963 arg1 = reinterpret_cast< wxSizer * >(argp1);
50964 arg2 = obj1;
50965 if (obj2) {
50966 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50967 if (!SWIG_IsOK(ecode3)) {
50968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50969 }
50970 arg3 = static_cast< bool >(val3);
50971 }
50972 if (obj3) {
50973 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50974 if (!SWIG_IsOK(ecode4)) {
50975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
50976 }
50977 arg4 = static_cast< bool >(val4);
50978 }
50979 {
50980 PyThreadState* __tstate = wxPyBeginAllowThreads();
50981 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
50982 wxPyEndAllowThreads(__tstate);
50983 if (PyErr_Occurred()) SWIG_fail;
50984 }
50985 {
50986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50987 }
50988 return resultobj;
50989 fail:
50990 return NULL;
50991 }
50992
50993
50994 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50995 PyObject *resultobj = 0;
50996 wxSizer *arg1 = (wxSizer *) 0 ;
50997 PyObject *arg2 = (PyObject *) 0 ;
50998 bool result;
50999 void *argp1 = 0 ;
51000 int res1 = 0 ;
51001 PyObject * obj0 = 0 ;
51002 PyObject * obj1 = 0 ;
51003 char * kwnames[] = {
51004 (char *) "self",(char *) "item", NULL
51005 };
51006
51007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51009 if (!SWIG_IsOK(res1)) {
51010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51011 }
51012 arg1 = reinterpret_cast< wxSizer * >(argp1);
51013 arg2 = obj1;
51014 {
51015 PyThreadState* __tstate = wxPyBeginAllowThreads();
51016 result = (bool)wxSizer_IsShown(arg1,arg2);
51017 wxPyEndAllowThreads(__tstate);
51018 if (PyErr_Occurred()) SWIG_fail;
51019 }
51020 {
51021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51022 }
51023 return resultobj;
51024 fail:
51025 return NULL;
51026 }
51027
51028
51029 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51030 PyObject *resultobj = 0;
51031 wxSizer *arg1 = (wxSizer *) 0 ;
51032 bool arg2 ;
51033 void *argp1 = 0 ;
51034 int res1 = 0 ;
51035 bool val2 ;
51036 int ecode2 = 0 ;
51037 PyObject * obj0 = 0 ;
51038 PyObject * obj1 = 0 ;
51039 char * kwnames[] = {
51040 (char *) "self",(char *) "show", NULL
51041 };
51042
51043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51045 if (!SWIG_IsOK(res1)) {
51046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51047 }
51048 arg1 = reinterpret_cast< wxSizer * >(argp1);
51049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51050 if (!SWIG_IsOK(ecode2)) {
51051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51052 }
51053 arg2 = static_cast< bool >(val2);
51054 {
51055 PyThreadState* __tstate = wxPyBeginAllowThreads();
51056 (arg1)->ShowItems(arg2);
51057 wxPyEndAllowThreads(__tstate);
51058 if (PyErr_Occurred()) SWIG_fail;
51059 }
51060 resultobj = SWIG_Py_Void();
51061 return resultobj;
51062 fail:
51063 return NULL;
51064 }
51065
51066
51067 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51068 PyObject *obj;
51069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51070 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51071 return SWIG_Py_Void();
51072 }
51073
51074 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51075 PyObject *resultobj = 0;
51076 wxPySizer *result = 0 ;
51077
51078 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51079 {
51080 PyThreadState* __tstate = wxPyBeginAllowThreads();
51081 result = (wxPySizer *)new wxPySizer();
51082 wxPyEndAllowThreads(__tstate);
51083 if (PyErr_Occurred()) SWIG_fail;
51084 }
51085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51086 return resultobj;
51087 fail:
51088 return NULL;
51089 }
51090
51091
51092 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51093 PyObject *resultobj = 0;
51094 wxPySizer *arg1 = (wxPySizer *) 0 ;
51095 PyObject *arg2 = (PyObject *) 0 ;
51096 PyObject *arg3 = (PyObject *) 0 ;
51097 void *argp1 = 0 ;
51098 int res1 = 0 ;
51099 PyObject * obj0 = 0 ;
51100 PyObject * obj1 = 0 ;
51101 PyObject * obj2 = 0 ;
51102 char * kwnames[] = {
51103 (char *) "self",(char *) "self",(char *) "_class", NULL
51104 };
51105
51106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51108 if (!SWIG_IsOK(res1)) {
51109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51110 }
51111 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51112 arg2 = obj1;
51113 arg3 = obj2;
51114 {
51115 PyThreadState* __tstate = wxPyBeginAllowThreads();
51116 (arg1)->_setCallbackInfo(arg2,arg3);
51117 wxPyEndAllowThreads(__tstate);
51118 if (PyErr_Occurred()) SWIG_fail;
51119 }
51120 resultobj = SWIG_Py_Void();
51121 return resultobj;
51122 fail:
51123 return NULL;
51124 }
51125
51126
51127 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51128 PyObject *obj;
51129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51130 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51131 return SWIG_Py_Void();
51132 }
51133
51134 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51135 return SWIG_Python_InitShadowInstance(args);
51136 }
51137
51138 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51139 PyObject *resultobj = 0;
51140 int arg1 = (int) wxHORIZONTAL ;
51141 wxBoxSizer *result = 0 ;
51142 int val1 ;
51143 int ecode1 = 0 ;
51144 PyObject * obj0 = 0 ;
51145 char * kwnames[] = {
51146 (char *) "orient", NULL
51147 };
51148
51149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51150 if (obj0) {
51151 ecode1 = SWIG_AsVal_int(obj0, &val1);
51152 if (!SWIG_IsOK(ecode1)) {
51153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51154 }
51155 arg1 = static_cast< int >(val1);
51156 }
51157 {
51158 PyThreadState* __tstate = wxPyBeginAllowThreads();
51159 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51160 wxPyEndAllowThreads(__tstate);
51161 if (PyErr_Occurred()) SWIG_fail;
51162 }
51163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51164 return resultobj;
51165 fail:
51166 return NULL;
51167 }
51168
51169
51170 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51171 PyObject *resultobj = 0;
51172 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51173 int result;
51174 void *argp1 = 0 ;
51175 int res1 = 0 ;
51176 PyObject *swig_obj[1] ;
51177
51178 if (!args) SWIG_fail;
51179 swig_obj[0] = args;
51180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51181 if (!SWIG_IsOK(res1)) {
51182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51183 }
51184 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51185 {
51186 PyThreadState* __tstate = wxPyBeginAllowThreads();
51187 result = (int)(arg1)->GetOrientation();
51188 wxPyEndAllowThreads(__tstate);
51189 if (PyErr_Occurred()) SWIG_fail;
51190 }
51191 resultobj = SWIG_From_int(static_cast< int >(result));
51192 return resultobj;
51193 fail:
51194 return NULL;
51195 }
51196
51197
51198 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51199 PyObject *resultobj = 0;
51200 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51201 int arg2 ;
51202 void *argp1 = 0 ;
51203 int res1 = 0 ;
51204 int val2 ;
51205 int ecode2 = 0 ;
51206 PyObject * obj0 = 0 ;
51207 PyObject * obj1 = 0 ;
51208 char * kwnames[] = {
51209 (char *) "self",(char *) "orient", NULL
51210 };
51211
51212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51214 if (!SWIG_IsOK(res1)) {
51215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51216 }
51217 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51218 ecode2 = SWIG_AsVal_int(obj1, &val2);
51219 if (!SWIG_IsOK(ecode2)) {
51220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51221 }
51222 arg2 = static_cast< int >(val2);
51223 {
51224 PyThreadState* __tstate = wxPyBeginAllowThreads();
51225 (arg1)->SetOrientation(arg2);
51226 wxPyEndAllowThreads(__tstate);
51227 if (PyErr_Occurred()) SWIG_fail;
51228 }
51229 resultobj = SWIG_Py_Void();
51230 return resultobj;
51231 fail:
51232 return NULL;
51233 }
51234
51235
51236 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51237 PyObject *obj;
51238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51239 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51240 return SWIG_Py_Void();
51241 }
51242
51243 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51244 return SWIG_Python_InitShadowInstance(args);
51245 }
51246
51247 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51248 PyObject *resultobj = 0;
51249 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51250 int arg2 = (int) wxHORIZONTAL ;
51251 wxStaticBoxSizer *result = 0 ;
51252 void *argp1 = 0 ;
51253 int res1 = 0 ;
51254 int val2 ;
51255 int ecode2 = 0 ;
51256 PyObject * obj0 = 0 ;
51257 PyObject * obj1 = 0 ;
51258 char * kwnames[] = {
51259 (char *) "box",(char *) "orient", NULL
51260 };
51261
51262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51264 if (!SWIG_IsOK(res1)) {
51265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51266 }
51267 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51268 if (obj1) {
51269 ecode2 = SWIG_AsVal_int(obj1, &val2);
51270 if (!SWIG_IsOK(ecode2)) {
51271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51272 }
51273 arg2 = static_cast< int >(val2);
51274 }
51275 {
51276 PyThreadState* __tstate = wxPyBeginAllowThreads();
51277 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51278 wxPyEndAllowThreads(__tstate);
51279 if (PyErr_Occurred()) SWIG_fail;
51280 }
51281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51282 return resultobj;
51283 fail:
51284 return NULL;
51285 }
51286
51287
51288 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51289 PyObject *resultobj = 0;
51290 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51291 wxStaticBox *result = 0 ;
51292 void *argp1 = 0 ;
51293 int res1 = 0 ;
51294 PyObject *swig_obj[1] ;
51295
51296 if (!args) SWIG_fail;
51297 swig_obj[0] = args;
51298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51299 if (!SWIG_IsOK(res1)) {
51300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51301 }
51302 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51303 {
51304 PyThreadState* __tstate = wxPyBeginAllowThreads();
51305 result = (wxStaticBox *)(arg1)->GetStaticBox();
51306 wxPyEndAllowThreads(__tstate);
51307 if (PyErr_Occurred()) SWIG_fail;
51308 }
51309 {
51310 resultobj = wxPyMake_wxObject(result, (bool)0);
51311 }
51312 return resultobj;
51313 fail:
51314 return NULL;
51315 }
51316
51317
51318 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51319 PyObject *obj;
51320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51321 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51322 return SWIG_Py_Void();
51323 }
51324
51325 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51326 return SWIG_Python_InitShadowInstance(args);
51327 }
51328
51329 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51330 PyObject *resultobj = 0;
51331 int arg1 = (int) 1 ;
51332 int arg2 = (int) 0 ;
51333 int arg3 = (int) 0 ;
51334 int arg4 = (int) 0 ;
51335 wxGridSizer *result = 0 ;
51336 int val1 ;
51337 int ecode1 = 0 ;
51338 int val2 ;
51339 int ecode2 = 0 ;
51340 int val3 ;
51341 int ecode3 = 0 ;
51342 int val4 ;
51343 int ecode4 = 0 ;
51344 PyObject * obj0 = 0 ;
51345 PyObject * obj1 = 0 ;
51346 PyObject * obj2 = 0 ;
51347 PyObject * obj3 = 0 ;
51348 char * kwnames[] = {
51349 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51350 };
51351
51352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51353 if (obj0) {
51354 ecode1 = SWIG_AsVal_int(obj0, &val1);
51355 if (!SWIG_IsOK(ecode1)) {
51356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51357 }
51358 arg1 = static_cast< int >(val1);
51359 }
51360 if (obj1) {
51361 ecode2 = SWIG_AsVal_int(obj1, &val2);
51362 if (!SWIG_IsOK(ecode2)) {
51363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51364 }
51365 arg2 = static_cast< int >(val2);
51366 }
51367 if (obj2) {
51368 ecode3 = SWIG_AsVal_int(obj2, &val3);
51369 if (!SWIG_IsOK(ecode3)) {
51370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51371 }
51372 arg3 = static_cast< int >(val3);
51373 }
51374 if (obj3) {
51375 ecode4 = SWIG_AsVal_int(obj3, &val4);
51376 if (!SWIG_IsOK(ecode4)) {
51377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51378 }
51379 arg4 = static_cast< int >(val4);
51380 }
51381 {
51382 PyThreadState* __tstate = wxPyBeginAllowThreads();
51383 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51384 wxPyEndAllowThreads(__tstate);
51385 if (PyErr_Occurred()) SWIG_fail;
51386 }
51387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51388 return resultobj;
51389 fail:
51390 return NULL;
51391 }
51392
51393
51394 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51395 PyObject *resultobj = 0;
51396 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51397 int arg2 ;
51398 void *argp1 = 0 ;
51399 int res1 = 0 ;
51400 int val2 ;
51401 int ecode2 = 0 ;
51402 PyObject * obj0 = 0 ;
51403 PyObject * obj1 = 0 ;
51404 char * kwnames[] = {
51405 (char *) "self",(char *) "cols", NULL
51406 };
51407
51408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51410 if (!SWIG_IsOK(res1)) {
51411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51412 }
51413 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51414 ecode2 = SWIG_AsVal_int(obj1, &val2);
51415 if (!SWIG_IsOK(ecode2)) {
51416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51417 }
51418 arg2 = static_cast< int >(val2);
51419 {
51420 PyThreadState* __tstate = wxPyBeginAllowThreads();
51421 (arg1)->SetCols(arg2);
51422 wxPyEndAllowThreads(__tstate);
51423 if (PyErr_Occurred()) SWIG_fail;
51424 }
51425 resultobj = SWIG_Py_Void();
51426 return resultobj;
51427 fail:
51428 return NULL;
51429 }
51430
51431
51432 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51433 PyObject *resultobj = 0;
51434 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51435 int arg2 ;
51436 void *argp1 = 0 ;
51437 int res1 = 0 ;
51438 int val2 ;
51439 int ecode2 = 0 ;
51440 PyObject * obj0 = 0 ;
51441 PyObject * obj1 = 0 ;
51442 char * kwnames[] = {
51443 (char *) "self",(char *) "rows", NULL
51444 };
51445
51446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51448 if (!SWIG_IsOK(res1)) {
51449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51450 }
51451 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51452 ecode2 = SWIG_AsVal_int(obj1, &val2);
51453 if (!SWIG_IsOK(ecode2)) {
51454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51455 }
51456 arg2 = static_cast< int >(val2);
51457 {
51458 PyThreadState* __tstate = wxPyBeginAllowThreads();
51459 (arg1)->SetRows(arg2);
51460 wxPyEndAllowThreads(__tstate);
51461 if (PyErr_Occurred()) SWIG_fail;
51462 }
51463 resultobj = SWIG_Py_Void();
51464 return resultobj;
51465 fail:
51466 return NULL;
51467 }
51468
51469
51470 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51471 PyObject *resultobj = 0;
51472 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51473 int arg2 ;
51474 void *argp1 = 0 ;
51475 int res1 = 0 ;
51476 int val2 ;
51477 int ecode2 = 0 ;
51478 PyObject * obj0 = 0 ;
51479 PyObject * obj1 = 0 ;
51480 char * kwnames[] = {
51481 (char *) "self",(char *) "gap", NULL
51482 };
51483
51484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51486 if (!SWIG_IsOK(res1)) {
51487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51488 }
51489 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51490 ecode2 = SWIG_AsVal_int(obj1, &val2);
51491 if (!SWIG_IsOK(ecode2)) {
51492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51493 }
51494 arg2 = static_cast< int >(val2);
51495 {
51496 PyThreadState* __tstate = wxPyBeginAllowThreads();
51497 (arg1)->SetVGap(arg2);
51498 wxPyEndAllowThreads(__tstate);
51499 if (PyErr_Occurred()) SWIG_fail;
51500 }
51501 resultobj = SWIG_Py_Void();
51502 return resultobj;
51503 fail:
51504 return NULL;
51505 }
51506
51507
51508 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51509 PyObject *resultobj = 0;
51510 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51511 int arg2 ;
51512 void *argp1 = 0 ;
51513 int res1 = 0 ;
51514 int val2 ;
51515 int ecode2 = 0 ;
51516 PyObject * obj0 = 0 ;
51517 PyObject * obj1 = 0 ;
51518 char * kwnames[] = {
51519 (char *) "self",(char *) "gap", NULL
51520 };
51521
51522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51524 if (!SWIG_IsOK(res1)) {
51525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51526 }
51527 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51528 ecode2 = SWIG_AsVal_int(obj1, &val2);
51529 if (!SWIG_IsOK(ecode2)) {
51530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51531 }
51532 arg2 = static_cast< int >(val2);
51533 {
51534 PyThreadState* __tstate = wxPyBeginAllowThreads();
51535 (arg1)->SetHGap(arg2);
51536 wxPyEndAllowThreads(__tstate);
51537 if (PyErr_Occurred()) SWIG_fail;
51538 }
51539 resultobj = SWIG_Py_Void();
51540 return resultobj;
51541 fail:
51542 return NULL;
51543 }
51544
51545
51546 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51547 PyObject *resultobj = 0;
51548 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51549 int result;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 PyObject *swig_obj[1] ;
51553
51554 if (!args) SWIG_fail;
51555 swig_obj[0] = args;
51556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51557 if (!SWIG_IsOK(res1)) {
51558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51559 }
51560 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51561 {
51562 PyThreadState* __tstate = wxPyBeginAllowThreads();
51563 result = (int)(arg1)->GetCols();
51564 wxPyEndAllowThreads(__tstate);
51565 if (PyErr_Occurred()) SWIG_fail;
51566 }
51567 resultobj = SWIG_From_int(static_cast< int >(result));
51568 return resultobj;
51569 fail:
51570 return NULL;
51571 }
51572
51573
51574 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51575 PyObject *resultobj = 0;
51576 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51577 int result;
51578 void *argp1 = 0 ;
51579 int res1 = 0 ;
51580 PyObject *swig_obj[1] ;
51581
51582 if (!args) SWIG_fail;
51583 swig_obj[0] = args;
51584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51585 if (!SWIG_IsOK(res1)) {
51586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51587 }
51588 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51589 {
51590 PyThreadState* __tstate = wxPyBeginAllowThreads();
51591 result = (int)(arg1)->GetRows();
51592 wxPyEndAllowThreads(__tstate);
51593 if (PyErr_Occurred()) SWIG_fail;
51594 }
51595 resultobj = SWIG_From_int(static_cast< int >(result));
51596 return resultobj;
51597 fail:
51598 return NULL;
51599 }
51600
51601
51602 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51603 PyObject *resultobj = 0;
51604 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51605 int result;
51606 void *argp1 = 0 ;
51607 int res1 = 0 ;
51608 PyObject *swig_obj[1] ;
51609
51610 if (!args) SWIG_fail;
51611 swig_obj[0] = args;
51612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51613 if (!SWIG_IsOK(res1)) {
51614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51615 }
51616 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 result = (int)(arg1)->GetVGap();
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 resultobj = SWIG_From_int(static_cast< int >(result));
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51631 PyObject *resultobj = 0;
51632 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51633 int result;
51634 void *argp1 = 0 ;
51635 int res1 = 0 ;
51636 PyObject *swig_obj[1] ;
51637
51638 if (!args) SWIG_fail;
51639 swig_obj[0] = args;
51640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51643 }
51644 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = (int)(arg1)->GetHGap();
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 resultobj = SWIG_From_int(static_cast< int >(result));
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51659 PyObject *obj;
51660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51661 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51662 return SWIG_Py_Void();
51663 }
51664
51665 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51666 return SWIG_Python_InitShadowInstance(args);
51667 }
51668
51669 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51670 PyObject *resultobj = 0;
51671 int arg1 = (int) 1 ;
51672 int arg2 = (int) 0 ;
51673 int arg3 = (int) 0 ;
51674 int arg4 = (int) 0 ;
51675 wxFlexGridSizer *result = 0 ;
51676 int val1 ;
51677 int ecode1 = 0 ;
51678 int val2 ;
51679 int ecode2 = 0 ;
51680 int val3 ;
51681 int ecode3 = 0 ;
51682 int val4 ;
51683 int ecode4 = 0 ;
51684 PyObject * obj0 = 0 ;
51685 PyObject * obj1 = 0 ;
51686 PyObject * obj2 = 0 ;
51687 PyObject * obj3 = 0 ;
51688 char * kwnames[] = {
51689 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51690 };
51691
51692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51693 if (obj0) {
51694 ecode1 = SWIG_AsVal_int(obj0, &val1);
51695 if (!SWIG_IsOK(ecode1)) {
51696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51697 }
51698 arg1 = static_cast< int >(val1);
51699 }
51700 if (obj1) {
51701 ecode2 = SWIG_AsVal_int(obj1, &val2);
51702 if (!SWIG_IsOK(ecode2)) {
51703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51704 }
51705 arg2 = static_cast< int >(val2);
51706 }
51707 if (obj2) {
51708 ecode3 = SWIG_AsVal_int(obj2, &val3);
51709 if (!SWIG_IsOK(ecode3)) {
51710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51711 }
51712 arg3 = static_cast< int >(val3);
51713 }
51714 if (obj3) {
51715 ecode4 = SWIG_AsVal_int(obj3, &val4);
51716 if (!SWIG_IsOK(ecode4)) {
51717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51718 }
51719 arg4 = static_cast< int >(val4);
51720 }
51721 {
51722 PyThreadState* __tstate = wxPyBeginAllowThreads();
51723 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51724 wxPyEndAllowThreads(__tstate);
51725 if (PyErr_Occurred()) SWIG_fail;
51726 }
51727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51728 return resultobj;
51729 fail:
51730 return NULL;
51731 }
51732
51733
51734 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51735 PyObject *resultobj = 0;
51736 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51737 size_t arg2 ;
51738 int arg3 = (int) 0 ;
51739 void *argp1 = 0 ;
51740 int res1 = 0 ;
51741 size_t val2 ;
51742 int ecode2 = 0 ;
51743 int val3 ;
51744 int ecode3 = 0 ;
51745 PyObject * obj0 = 0 ;
51746 PyObject * obj1 = 0 ;
51747 PyObject * obj2 = 0 ;
51748 char * kwnames[] = {
51749 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51750 };
51751
51752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51754 if (!SWIG_IsOK(res1)) {
51755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51756 }
51757 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51758 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51759 if (!SWIG_IsOK(ecode2)) {
51760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51761 }
51762 arg2 = static_cast< size_t >(val2);
51763 if (obj2) {
51764 ecode3 = SWIG_AsVal_int(obj2, &val3);
51765 if (!SWIG_IsOK(ecode3)) {
51766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51767 }
51768 arg3 = static_cast< int >(val3);
51769 }
51770 {
51771 PyThreadState* __tstate = wxPyBeginAllowThreads();
51772 (arg1)->AddGrowableRow(arg2,arg3);
51773 wxPyEndAllowThreads(__tstate);
51774 if (PyErr_Occurred()) SWIG_fail;
51775 }
51776 resultobj = SWIG_Py_Void();
51777 return resultobj;
51778 fail:
51779 return NULL;
51780 }
51781
51782
51783 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51784 PyObject *resultobj = 0;
51785 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51786 size_t arg2 ;
51787 void *argp1 = 0 ;
51788 int res1 = 0 ;
51789 size_t val2 ;
51790 int ecode2 = 0 ;
51791 PyObject * obj0 = 0 ;
51792 PyObject * obj1 = 0 ;
51793 char * kwnames[] = {
51794 (char *) "self",(char *) "idx", NULL
51795 };
51796
51797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51799 if (!SWIG_IsOK(res1)) {
51800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51801 }
51802 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51803 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51804 if (!SWIG_IsOK(ecode2)) {
51805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51806 }
51807 arg2 = static_cast< size_t >(val2);
51808 {
51809 PyThreadState* __tstate = wxPyBeginAllowThreads();
51810 (arg1)->RemoveGrowableRow(arg2);
51811 wxPyEndAllowThreads(__tstate);
51812 if (PyErr_Occurred()) SWIG_fail;
51813 }
51814 resultobj = SWIG_Py_Void();
51815 return resultobj;
51816 fail:
51817 return NULL;
51818 }
51819
51820
51821 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51822 PyObject *resultobj = 0;
51823 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51824 size_t arg2 ;
51825 int arg3 = (int) 0 ;
51826 void *argp1 = 0 ;
51827 int res1 = 0 ;
51828 size_t val2 ;
51829 int ecode2 = 0 ;
51830 int val3 ;
51831 int ecode3 = 0 ;
51832 PyObject * obj0 = 0 ;
51833 PyObject * obj1 = 0 ;
51834 PyObject * obj2 = 0 ;
51835 char * kwnames[] = {
51836 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51837 };
51838
51839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51841 if (!SWIG_IsOK(res1)) {
51842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51843 }
51844 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51845 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51846 if (!SWIG_IsOK(ecode2)) {
51847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51848 }
51849 arg2 = static_cast< size_t >(val2);
51850 if (obj2) {
51851 ecode3 = SWIG_AsVal_int(obj2, &val3);
51852 if (!SWIG_IsOK(ecode3)) {
51853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51854 }
51855 arg3 = static_cast< int >(val3);
51856 }
51857 {
51858 PyThreadState* __tstate = wxPyBeginAllowThreads();
51859 (arg1)->AddGrowableCol(arg2,arg3);
51860 wxPyEndAllowThreads(__tstate);
51861 if (PyErr_Occurred()) SWIG_fail;
51862 }
51863 resultobj = SWIG_Py_Void();
51864 return resultobj;
51865 fail:
51866 return NULL;
51867 }
51868
51869
51870 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51871 PyObject *resultobj = 0;
51872 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51873 size_t arg2 ;
51874 void *argp1 = 0 ;
51875 int res1 = 0 ;
51876 size_t val2 ;
51877 int ecode2 = 0 ;
51878 PyObject * obj0 = 0 ;
51879 PyObject * obj1 = 0 ;
51880 char * kwnames[] = {
51881 (char *) "self",(char *) "idx", NULL
51882 };
51883
51884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51886 if (!SWIG_IsOK(res1)) {
51887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51888 }
51889 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51890 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51891 if (!SWIG_IsOK(ecode2)) {
51892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51893 }
51894 arg2 = static_cast< size_t >(val2);
51895 {
51896 PyThreadState* __tstate = wxPyBeginAllowThreads();
51897 (arg1)->RemoveGrowableCol(arg2);
51898 wxPyEndAllowThreads(__tstate);
51899 if (PyErr_Occurred()) SWIG_fail;
51900 }
51901 resultobj = SWIG_Py_Void();
51902 return resultobj;
51903 fail:
51904 return NULL;
51905 }
51906
51907
51908 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51909 PyObject *resultobj = 0;
51910 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51911 int arg2 ;
51912 void *argp1 = 0 ;
51913 int res1 = 0 ;
51914 int val2 ;
51915 int ecode2 = 0 ;
51916 PyObject * obj0 = 0 ;
51917 PyObject * obj1 = 0 ;
51918 char * kwnames[] = {
51919 (char *) "self",(char *) "direction", NULL
51920 };
51921
51922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51924 if (!SWIG_IsOK(res1)) {
51925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51926 }
51927 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51928 ecode2 = SWIG_AsVal_int(obj1, &val2);
51929 if (!SWIG_IsOK(ecode2)) {
51930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51931 }
51932 arg2 = static_cast< int >(val2);
51933 {
51934 PyThreadState* __tstate = wxPyBeginAllowThreads();
51935 (arg1)->SetFlexibleDirection(arg2);
51936 wxPyEndAllowThreads(__tstate);
51937 if (PyErr_Occurred()) SWIG_fail;
51938 }
51939 resultobj = SWIG_Py_Void();
51940 return resultobj;
51941 fail:
51942 return NULL;
51943 }
51944
51945
51946 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51947 PyObject *resultobj = 0;
51948 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51949 int result;
51950 void *argp1 = 0 ;
51951 int res1 = 0 ;
51952 PyObject *swig_obj[1] ;
51953
51954 if (!args) SWIG_fail;
51955 swig_obj[0] = args;
51956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51957 if (!SWIG_IsOK(res1)) {
51958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51959 }
51960 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51961 {
51962 PyThreadState* __tstate = wxPyBeginAllowThreads();
51963 result = (int)(arg1)->GetFlexibleDirection();
51964 wxPyEndAllowThreads(__tstate);
51965 if (PyErr_Occurred()) SWIG_fail;
51966 }
51967 resultobj = SWIG_From_int(static_cast< int >(result));
51968 return resultobj;
51969 fail:
51970 return NULL;
51971 }
51972
51973
51974 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51975 PyObject *resultobj = 0;
51976 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51977 wxFlexSizerGrowMode arg2 ;
51978 void *argp1 = 0 ;
51979 int res1 = 0 ;
51980 int val2 ;
51981 int ecode2 = 0 ;
51982 PyObject * obj0 = 0 ;
51983 PyObject * obj1 = 0 ;
51984 char * kwnames[] = {
51985 (char *) "self",(char *) "mode", NULL
51986 };
51987
51988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
51989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51990 if (!SWIG_IsOK(res1)) {
51991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51992 }
51993 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51994 ecode2 = SWIG_AsVal_int(obj1, &val2);
51995 if (!SWIG_IsOK(ecode2)) {
51996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
51997 }
51998 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
51999 {
52000 PyThreadState* __tstate = wxPyBeginAllowThreads();
52001 (arg1)->SetNonFlexibleGrowMode(arg2);
52002 wxPyEndAllowThreads(__tstate);
52003 if (PyErr_Occurred()) SWIG_fail;
52004 }
52005 resultobj = SWIG_Py_Void();
52006 return resultobj;
52007 fail:
52008 return NULL;
52009 }
52010
52011
52012 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52013 PyObject *resultobj = 0;
52014 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52015 wxFlexSizerGrowMode result;
52016 void *argp1 = 0 ;
52017 int res1 = 0 ;
52018 PyObject *swig_obj[1] ;
52019
52020 if (!args) SWIG_fail;
52021 swig_obj[0] = args;
52022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52023 if (!SWIG_IsOK(res1)) {
52024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52025 }
52026 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52027 {
52028 PyThreadState* __tstate = wxPyBeginAllowThreads();
52029 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52030 wxPyEndAllowThreads(__tstate);
52031 if (PyErr_Occurred()) SWIG_fail;
52032 }
52033 resultobj = SWIG_From_int(static_cast< int >(result));
52034 return resultobj;
52035 fail:
52036 return NULL;
52037 }
52038
52039
52040 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52041 PyObject *resultobj = 0;
52042 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52043 wxArrayInt *result = 0 ;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 PyObject *swig_obj[1] ;
52047
52048 if (!args) SWIG_fail;
52049 swig_obj[0] = args;
52050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52051 if (!SWIG_IsOK(res1)) {
52052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52053 }
52054 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52055 {
52056 PyThreadState* __tstate = wxPyBeginAllowThreads();
52057 {
52058 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52059 result = (wxArrayInt *) &_result_ref;
52060 }
52061 wxPyEndAllowThreads(__tstate);
52062 if (PyErr_Occurred()) SWIG_fail;
52063 }
52064 {
52065 resultobj = wxArrayInt2PyList_helper(*result);
52066 }
52067 return resultobj;
52068 fail:
52069 return NULL;
52070 }
52071
52072
52073 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52074 PyObject *resultobj = 0;
52075 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52076 wxArrayInt *result = 0 ;
52077 void *argp1 = 0 ;
52078 int res1 = 0 ;
52079 PyObject *swig_obj[1] ;
52080
52081 if (!args) SWIG_fail;
52082 swig_obj[0] = args;
52083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52084 if (!SWIG_IsOK(res1)) {
52085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52086 }
52087 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52088 {
52089 PyThreadState* __tstate = wxPyBeginAllowThreads();
52090 {
52091 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52092 result = (wxArrayInt *) &_result_ref;
52093 }
52094 wxPyEndAllowThreads(__tstate);
52095 if (PyErr_Occurred()) SWIG_fail;
52096 }
52097 {
52098 resultobj = wxArrayInt2PyList_helper(*result);
52099 }
52100 return resultobj;
52101 fail:
52102 return NULL;
52103 }
52104
52105
52106 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52107 PyObject *obj;
52108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52109 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52110 return SWIG_Py_Void();
52111 }
52112
52113 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52114 return SWIG_Python_InitShadowInstance(args);
52115 }
52116
52117 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52118 PyObject *resultobj = 0;
52119 wxStdDialogButtonSizer *result = 0 ;
52120
52121 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52122 {
52123 PyThreadState* __tstate = wxPyBeginAllowThreads();
52124 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52125 wxPyEndAllowThreads(__tstate);
52126 if (PyErr_Occurred()) SWIG_fail;
52127 }
52128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52129 return resultobj;
52130 fail:
52131 return NULL;
52132 }
52133
52134
52135 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52136 PyObject *resultobj = 0;
52137 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52138 wxButton *arg2 = (wxButton *) 0 ;
52139 void *argp1 = 0 ;
52140 int res1 = 0 ;
52141 void *argp2 = 0 ;
52142 int res2 = 0 ;
52143 PyObject * obj0 = 0 ;
52144 PyObject * obj1 = 0 ;
52145 char * kwnames[] = {
52146 (char *) "self",(char *) "button", NULL
52147 };
52148
52149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52151 if (!SWIG_IsOK(res1)) {
52152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52153 }
52154 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52156 if (!SWIG_IsOK(res2)) {
52157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52158 }
52159 arg2 = reinterpret_cast< wxButton * >(argp2);
52160 {
52161 PyThreadState* __tstate = wxPyBeginAllowThreads();
52162 (arg1)->AddButton(arg2);
52163 wxPyEndAllowThreads(__tstate);
52164 if (PyErr_Occurred()) SWIG_fail;
52165 }
52166 resultobj = SWIG_Py_Void();
52167 return resultobj;
52168 fail:
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52174 PyObject *resultobj = 0;
52175 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52176 void *argp1 = 0 ;
52177 int res1 = 0 ;
52178 PyObject *swig_obj[1] ;
52179
52180 if (!args) SWIG_fail;
52181 swig_obj[0] = args;
52182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52183 if (!SWIG_IsOK(res1)) {
52184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52185 }
52186 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52187 {
52188 PyThreadState* __tstate = wxPyBeginAllowThreads();
52189 (arg1)->Realize();
52190 wxPyEndAllowThreads(__tstate);
52191 if (PyErr_Occurred()) SWIG_fail;
52192 }
52193 resultobj = SWIG_Py_Void();
52194 return resultobj;
52195 fail:
52196 return NULL;
52197 }
52198
52199
52200 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52201 PyObject *resultobj = 0;
52202 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52203 wxButton *arg2 = (wxButton *) 0 ;
52204 void *argp1 = 0 ;
52205 int res1 = 0 ;
52206 void *argp2 = 0 ;
52207 int res2 = 0 ;
52208 PyObject * obj0 = 0 ;
52209 PyObject * obj1 = 0 ;
52210 char * kwnames[] = {
52211 (char *) "self",(char *) "button", NULL
52212 };
52213
52214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52216 if (!SWIG_IsOK(res1)) {
52217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52218 }
52219 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52221 if (!SWIG_IsOK(res2)) {
52222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52223 }
52224 arg2 = reinterpret_cast< wxButton * >(argp2);
52225 {
52226 PyThreadState* __tstate = wxPyBeginAllowThreads();
52227 (arg1)->SetAffirmativeButton(arg2);
52228 wxPyEndAllowThreads(__tstate);
52229 if (PyErr_Occurred()) SWIG_fail;
52230 }
52231 resultobj = SWIG_Py_Void();
52232 return resultobj;
52233 fail:
52234 return NULL;
52235 }
52236
52237
52238 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52239 PyObject *resultobj = 0;
52240 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52241 wxButton *arg2 = (wxButton *) 0 ;
52242 void *argp1 = 0 ;
52243 int res1 = 0 ;
52244 void *argp2 = 0 ;
52245 int res2 = 0 ;
52246 PyObject * obj0 = 0 ;
52247 PyObject * obj1 = 0 ;
52248 char * kwnames[] = {
52249 (char *) "self",(char *) "button", NULL
52250 };
52251
52252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52256 }
52257 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52259 if (!SWIG_IsOK(res2)) {
52260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52261 }
52262 arg2 = reinterpret_cast< wxButton * >(argp2);
52263 {
52264 PyThreadState* __tstate = wxPyBeginAllowThreads();
52265 (arg1)->SetNegativeButton(arg2);
52266 wxPyEndAllowThreads(__tstate);
52267 if (PyErr_Occurred()) SWIG_fail;
52268 }
52269 resultobj = SWIG_Py_Void();
52270 return resultobj;
52271 fail:
52272 return NULL;
52273 }
52274
52275
52276 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52277 PyObject *resultobj = 0;
52278 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52279 wxButton *arg2 = (wxButton *) 0 ;
52280 void *argp1 = 0 ;
52281 int res1 = 0 ;
52282 void *argp2 = 0 ;
52283 int res2 = 0 ;
52284 PyObject * obj0 = 0 ;
52285 PyObject * obj1 = 0 ;
52286 char * kwnames[] = {
52287 (char *) "self",(char *) "button", NULL
52288 };
52289
52290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52292 if (!SWIG_IsOK(res1)) {
52293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52294 }
52295 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52297 if (!SWIG_IsOK(res2)) {
52298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52299 }
52300 arg2 = reinterpret_cast< wxButton * >(argp2);
52301 {
52302 PyThreadState* __tstate = wxPyBeginAllowThreads();
52303 (arg1)->SetCancelButton(arg2);
52304 wxPyEndAllowThreads(__tstate);
52305 if (PyErr_Occurred()) SWIG_fail;
52306 }
52307 resultobj = SWIG_Py_Void();
52308 return resultobj;
52309 fail:
52310 return NULL;
52311 }
52312
52313
52314 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52315 PyObject *resultobj = 0;
52316 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52317 wxButton *result = 0 ;
52318 void *argp1 = 0 ;
52319 int res1 = 0 ;
52320 PyObject *swig_obj[1] ;
52321
52322 if (!args) SWIG_fail;
52323 swig_obj[0] = args;
52324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52325 if (!SWIG_IsOK(res1)) {
52326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52327 }
52328 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52329 {
52330 PyThreadState* __tstate = wxPyBeginAllowThreads();
52331 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52332 wxPyEndAllowThreads(__tstate);
52333 if (PyErr_Occurred()) SWIG_fail;
52334 }
52335 {
52336 resultobj = wxPyMake_wxObject(result, (bool)0);
52337 }
52338 return resultobj;
52339 fail:
52340 return NULL;
52341 }
52342
52343
52344 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52345 PyObject *resultobj = 0;
52346 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52347 wxButton *result = 0 ;
52348 void *argp1 = 0 ;
52349 int res1 = 0 ;
52350 PyObject *swig_obj[1] ;
52351
52352 if (!args) SWIG_fail;
52353 swig_obj[0] = args;
52354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52357 }
52358 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52359 {
52360 PyThreadState* __tstate = wxPyBeginAllowThreads();
52361 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52362 wxPyEndAllowThreads(__tstate);
52363 if (PyErr_Occurred()) SWIG_fail;
52364 }
52365 {
52366 resultobj = wxPyMake_wxObject(result, (bool)0);
52367 }
52368 return resultobj;
52369 fail:
52370 return NULL;
52371 }
52372
52373
52374 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52375 PyObject *resultobj = 0;
52376 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52377 wxButton *result = 0 ;
52378 void *argp1 = 0 ;
52379 int res1 = 0 ;
52380 PyObject *swig_obj[1] ;
52381
52382 if (!args) SWIG_fail;
52383 swig_obj[0] = args;
52384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52385 if (!SWIG_IsOK(res1)) {
52386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52387 }
52388 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52389 {
52390 PyThreadState* __tstate = wxPyBeginAllowThreads();
52391 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52392 wxPyEndAllowThreads(__tstate);
52393 if (PyErr_Occurred()) SWIG_fail;
52394 }
52395 {
52396 resultobj = wxPyMake_wxObject(result, (bool)0);
52397 }
52398 return resultobj;
52399 fail:
52400 return NULL;
52401 }
52402
52403
52404 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52405 PyObject *resultobj = 0;
52406 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52407 wxButton *result = 0 ;
52408 void *argp1 = 0 ;
52409 int res1 = 0 ;
52410 PyObject *swig_obj[1] ;
52411
52412 if (!args) SWIG_fail;
52413 swig_obj[0] = args;
52414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52415 if (!SWIG_IsOK(res1)) {
52416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52417 }
52418 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52419 {
52420 PyThreadState* __tstate = wxPyBeginAllowThreads();
52421 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52422 wxPyEndAllowThreads(__tstate);
52423 if (PyErr_Occurred()) SWIG_fail;
52424 }
52425 {
52426 resultobj = wxPyMake_wxObject(result, (bool)0);
52427 }
52428 return resultobj;
52429 fail:
52430 return NULL;
52431 }
52432
52433
52434 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52435 PyObject *resultobj = 0;
52436 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52437 wxButton *result = 0 ;
52438 void *argp1 = 0 ;
52439 int res1 = 0 ;
52440 PyObject *swig_obj[1] ;
52441
52442 if (!args) SWIG_fail;
52443 swig_obj[0] = args;
52444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52445 if (!SWIG_IsOK(res1)) {
52446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52447 }
52448 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52449 {
52450 PyThreadState* __tstate = wxPyBeginAllowThreads();
52451 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52452 wxPyEndAllowThreads(__tstate);
52453 if (PyErr_Occurred()) SWIG_fail;
52454 }
52455 {
52456 resultobj = wxPyMake_wxObject(result, (bool)0);
52457 }
52458 return resultobj;
52459 fail:
52460 return NULL;
52461 }
52462
52463
52464 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52465 PyObject *obj;
52466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52467 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52468 return SWIG_Py_Void();
52469 }
52470
52471 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52472 return SWIG_Python_InitShadowInstance(args);
52473 }
52474
52475 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52476 PyObject *resultobj = 0;
52477 int arg1 = (int) 0 ;
52478 int arg2 = (int) 0 ;
52479 wxGBPosition *result = 0 ;
52480 int val1 ;
52481 int ecode1 = 0 ;
52482 int val2 ;
52483 int ecode2 = 0 ;
52484 PyObject * obj0 = 0 ;
52485 PyObject * obj1 = 0 ;
52486 char * kwnames[] = {
52487 (char *) "row",(char *) "col", NULL
52488 };
52489
52490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52491 if (obj0) {
52492 ecode1 = SWIG_AsVal_int(obj0, &val1);
52493 if (!SWIG_IsOK(ecode1)) {
52494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52495 }
52496 arg1 = static_cast< int >(val1);
52497 }
52498 if (obj1) {
52499 ecode2 = SWIG_AsVal_int(obj1, &val2);
52500 if (!SWIG_IsOK(ecode2)) {
52501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52502 }
52503 arg2 = static_cast< int >(val2);
52504 }
52505 {
52506 PyThreadState* __tstate = wxPyBeginAllowThreads();
52507 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52508 wxPyEndAllowThreads(__tstate);
52509 if (PyErr_Occurred()) SWIG_fail;
52510 }
52511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52512 return resultobj;
52513 fail:
52514 return NULL;
52515 }
52516
52517
52518 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52519 PyObject *resultobj = 0;
52520 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52521 void *argp1 = 0 ;
52522 int res1 = 0 ;
52523 PyObject *swig_obj[1] ;
52524
52525 if (!args) SWIG_fail;
52526 swig_obj[0] = args;
52527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52528 if (!SWIG_IsOK(res1)) {
52529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52530 }
52531 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52532 {
52533 PyThreadState* __tstate = wxPyBeginAllowThreads();
52534 delete arg1;
52535
52536 wxPyEndAllowThreads(__tstate);
52537 if (PyErr_Occurred()) SWIG_fail;
52538 }
52539 resultobj = SWIG_Py_Void();
52540 return resultobj;
52541 fail:
52542 return NULL;
52543 }
52544
52545
52546 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52547 PyObject *resultobj = 0;
52548 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52549 int result;
52550 void *argp1 = 0 ;
52551 int res1 = 0 ;
52552 PyObject *swig_obj[1] ;
52553
52554 if (!args) SWIG_fail;
52555 swig_obj[0] = args;
52556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52557 if (!SWIG_IsOK(res1)) {
52558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52559 }
52560 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52561 {
52562 PyThreadState* __tstate = wxPyBeginAllowThreads();
52563 result = (int)((wxGBPosition const *)arg1)->GetRow();
52564 wxPyEndAllowThreads(__tstate);
52565 if (PyErr_Occurred()) SWIG_fail;
52566 }
52567 resultobj = SWIG_From_int(static_cast< int >(result));
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52575 PyObject *resultobj = 0;
52576 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52577 int result;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 PyObject *swig_obj[1] ;
52581
52582 if (!args) SWIG_fail;
52583 swig_obj[0] = args;
52584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52585 if (!SWIG_IsOK(res1)) {
52586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52587 }
52588 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 result = (int)((wxGBPosition const *)arg1)->GetCol();
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_From_int(static_cast< int >(result));
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52603 PyObject *resultobj = 0;
52604 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52605 int arg2 ;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 int val2 ;
52609 int ecode2 = 0 ;
52610 PyObject * obj0 = 0 ;
52611 PyObject * obj1 = 0 ;
52612 char * kwnames[] = {
52613 (char *) "self",(char *) "row", NULL
52614 };
52615
52616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52618 if (!SWIG_IsOK(res1)) {
52619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52620 }
52621 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52622 ecode2 = SWIG_AsVal_int(obj1, &val2);
52623 if (!SWIG_IsOK(ecode2)) {
52624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52625 }
52626 arg2 = static_cast< int >(val2);
52627 {
52628 PyThreadState* __tstate = wxPyBeginAllowThreads();
52629 (arg1)->SetRow(arg2);
52630 wxPyEndAllowThreads(__tstate);
52631 if (PyErr_Occurred()) SWIG_fail;
52632 }
52633 resultobj = SWIG_Py_Void();
52634 return resultobj;
52635 fail:
52636 return NULL;
52637 }
52638
52639
52640 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52641 PyObject *resultobj = 0;
52642 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52643 int arg2 ;
52644 void *argp1 = 0 ;
52645 int res1 = 0 ;
52646 int val2 ;
52647 int ecode2 = 0 ;
52648 PyObject * obj0 = 0 ;
52649 PyObject * obj1 = 0 ;
52650 char * kwnames[] = {
52651 (char *) "self",(char *) "col", NULL
52652 };
52653
52654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52656 if (!SWIG_IsOK(res1)) {
52657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52658 }
52659 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52660 ecode2 = SWIG_AsVal_int(obj1, &val2);
52661 if (!SWIG_IsOK(ecode2)) {
52662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52663 }
52664 arg2 = static_cast< int >(val2);
52665 {
52666 PyThreadState* __tstate = wxPyBeginAllowThreads();
52667 (arg1)->SetCol(arg2);
52668 wxPyEndAllowThreads(__tstate);
52669 if (PyErr_Occurred()) SWIG_fail;
52670 }
52671 resultobj = SWIG_Py_Void();
52672 return resultobj;
52673 fail:
52674 return NULL;
52675 }
52676
52677
52678 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52679 PyObject *resultobj = 0;
52680 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52681 PyObject *arg2 = (PyObject *) 0 ;
52682 bool result;
52683 void *argp1 = 0 ;
52684 int res1 = 0 ;
52685 PyObject * obj0 = 0 ;
52686 PyObject * obj1 = 0 ;
52687 char * kwnames[] = {
52688 (char *) "self",(char *) "other", NULL
52689 };
52690
52691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52693 if (!SWIG_IsOK(res1)) {
52694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52695 }
52696 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52697 arg2 = obj1;
52698 {
52699 result = (bool)wxGBPosition___eq__(arg1,arg2);
52700 if (PyErr_Occurred()) SWIG_fail;
52701 }
52702 {
52703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52704 }
52705 return resultobj;
52706 fail:
52707 return NULL;
52708 }
52709
52710
52711 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52712 PyObject *resultobj = 0;
52713 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52714 PyObject *arg2 = (PyObject *) 0 ;
52715 bool result;
52716 void *argp1 = 0 ;
52717 int res1 = 0 ;
52718 PyObject * obj0 = 0 ;
52719 PyObject * obj1 = 0 ;
52720 char * kwnames[] = {
52721 (char *) "self",(char *) "other", NULL
52722 };
52723
52724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52726 if (!SWIG_IsOK(res1)) {
52727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52728 }
52729 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52730 arg2 = obj1;
52731 {
52732 result = (bool)wxGBPosition___ne__(arg1,arg2);
52733 if (PyErr_Occurred()) SWIG_fail;
52734 }
52735 {
52736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52737 }
52738 return resultobj;
52739 fail:
52740 return NULL;
52741 }
52742
52743
52744 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52745 PyObject *resultobj = 0;
52746 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52747 int arg2 = (int) 0 ;
52748 int arg3 = (int) 0 ;
52749 void *argp1 = 0 ;
52750 int res1 = 0 ;
52751 int val2 ;
52752 int ecode2 = 0 ;
52753 int val3 ;
52754 int ecode3 = 0 ;
52755 PyObject * obj0 = 0 ;
52756 PyObject * obj1 = 0 ;
52757 PyObject * obj2 = 0 ;
52758 char * kwnames[] = {
52759 (char *) "self",(char *) "row",(char *) "col", NULL
52760 };
52761
52762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52764 if (!SWIG_IsOK(res1)) {
52765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52766 }
52767 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52768 if (obj1) {
52769 ecode2 = SWIG_AsVal_int(obj1, &val2);
52770 if (!SWIG_IsOK(ecode2)) {
52771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52772 }
52773 arg2 = static_cast< int >(val2);
52774 }
52775 if (obj2) {
52776 ecode3 = SWIG_AsVal_int(obj2, &val3);
52777 if (!SWIG_IsOK(ecode3)) {
52778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52779 }
52780 arg3 = static_cast< int >(val3);
52781 }
52782 {
52783 PyThreadState* __tstate = wxPyBeginAllowThreads();
52784 wxGBPosition_Set(arg1,arg2,arg3);
52785 wxPyEndAllowThreads(__tstate);
52786 if (PyErr_Occurred()) SWIG_fail;
52787 }
52788 resultobj = SWIG_Py_Void();
52789 return resultobj;
52790 fail:
52791 return NULL;
52792 }
52793
52794
52795 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52796 PyObject *resultobj = 0;
52797 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52798 PyObject *result = 0 ;
52799 void *argp1 = 0 ;
52800 int res1 = 0 ;
52801 PyObject *swig_obj[1] ;
52802
52803 if (!args) SWIG_fail;
52804 swig_obj[0] = args;
52805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52806 if (!SWIG_IsOK(res1)) {
52807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52808 }
52809 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52810 {
52811 PyThreadState* __tstate = wxPyBeginAllowThreads();
52812 result = (PyObject *)wxGBPosition_Get(arg1);
52813 wxPyEndAllowThreads(__tstate);
52814 if (PyErr_Occurred()) SWIG_fail;
52815 }
52816 resultobj = result;
52817 return resultobj;
52818 fail:
52819 return NULL;
52820 }
52821
52822
52823 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52824 PyObject *obj;
52825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52826 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52827 return SWIG_Py_Void();
52828 }
52829
52830 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52831 return SWIG_Python_InitShadowInstance(args);
52832 }
52833
52834 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52835 PyObject *resultobj = 0;
52836 int arg1 = (int) 1 ;
52837 int arg2 = (int) 1 ;
52838 wxGBSpan *result = 0 ;
52839 int val1 ;
52840 int ecode1 = 0 ;
52841 int val2 ;
52842 int ecode2 = 0 ;
52843 PyObject * obj0 = 0 ;
52844 PyObject * obj1 = 0 ;
52845 char * kwnames[] = {
52846 (char *) "rowspan",(char *) "colspan", NULL
52847 };
52848
52849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52850 if (obj0) {
52851 ecode1 = SWIG_AsVal_int(obj0, &val1);
52852 if (!SWIG_IsOK(ecode1)) {
52853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52854 }
52855 arg1 = static_cast< int >(val1);
52856 }
52857 if (obj1) {
52858 ecode2 = SWIG_AsVal_int(obj1, &val2);
52859 if (!SWIG_IsOK(ecode2)) {
52860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52861 }
52862 arg2 = static_cast< int >(val2);
52863 }
52864 {
52865 PyThreadState* __tstate = wxPyBeginAllowThreads();
52866 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52867 wxPyEndAllowThreads(__tstate);
52868 if (PyErr_Occurred()) SWIG_fail;
52869 }
52870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52871 return resultobj;
52872 fail:
52873 return NULL;
52874 }
52875
52876
52877 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52878 PyObject *resultobj = 0;
52879 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52880 void *argp1 = 0 ;
52881 int res1 = 0 ;
52882 PyObject *swig_obj[1] ;
52883
52884 if (!args) SWIG_fail;
52885 swig_obj[0] = args;
52886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52887 if (!SWIG_IsOK(res1)) {
52888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52889 }
52890 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52891 {
52892 PyThreadState* __tstate = wxPyBeginAllowThreads();
52893 delete arg1;
52894
52895 wxPyEndAllowThreads(__tstate);
52896 if (PyErr_Occurred()) SWIG_fail;
52897 }
52898 resultobj = SWIG_Py_Void();
52899 return resultobj;
52900 fail:
52901 return NULL;
52902 }
52903
52904
52905 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52906 PyObject *resultobj = 0;
52907 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52908 int result;
52909 void *argp1 = 0 ;
52910 int res1 = 0 ;
52911 PyObject *swig_obj[1] ;
52912
52913 if (!args) SWIG_fail;
52914 swig_obj[0] = args;
52915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52916 if (!SWIG_IsOK(res1)) {
52917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52918 }
52919 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52920 {
52921 PyThreadState* __tstate = wxPyBeginAllowThreads();
52922 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52923 wxPyEndAllowThreads(__tstate);
52924 if (PyErr_Occurred()) SWIG_fail;
52925 }
52926 resultobj = SWIG_From_int(static_cast< int >(result));
52927 return resultobj;
52928 fail:
52929 return NULL;
52930 }
52931
52932
52933 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52934 PyObject *resultobj = 0;
52935 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52936 int result;
52937 void *argp1 = 0 ;
52938 int res1 = 0 ;
52939 PyObject *swig_obj[1] ;
52940
52941 if (!args) SWIG_fail;
52942 swig_obj[0] = args;
52943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52944 if (!SWIG_IsOK(res1)) {
52945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52946 }
52947 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52948 {
52949 PyThreadState* __tstate = wxPyBeginAllowThreads();
52950 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52951 wxPyEndAllowThreads(__tstate);
52952 if (PyErr_Occurred()) SWIG_fail;
52953 }
52954 resultobj = SWIG_From_int(static_cast< int >(result));
52955 return resultobj;
52956 fail:
52957 return NULL;
52958 }
52959
52960
52961 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52962 PyObject *resultobj = 0;
52963 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52964 int arg2 ;
52965 void *argp1 = 0 ;
52966 int res1 = 0 ;
52967 int val2 ;
52968 int ecode2 = 0 ;
52969 PyObject * obj0 = 0 ;
52970 PyObject * obj1 = 0 ;
52971 char * kwnames[] = {
52972 (char *) "self",(char *) "rowspan", NULL
52973 };
52974
52975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
52976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52977 if (!SWIG_IsOK(res1)) {
52978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52979 }
52980 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52981 ecode2 = SWIG_AsVal_int(obj1, &val2);
52982 if (!SWIG_IsOK(ecode2)) {
52983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
52984 }
52985 arg2 = static_cast< int >(val2);
52986 {
52987 PyThreadState* __tstate = wxPyBeginAllowThreads();
52988 (arg1)->SetRowspan(arg2);
52989 wxPyEndAllowThreads(__tstate);
52990 if (PyErr_Occurred()) SWIG_fail;
52991 }
52992 resultobj = SWIG_Py_Void();
52993 return resultobj;
52994 fail:
52995 return NULL;
52996 }
52997
52998
52999 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53000 PyObject *resultobj = 0;
53001 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53002 int arg2 ;
53003 void *argp1 = 0 ;
53004 int res1 = 0 ;
53005 int val2 ;
53006 int ecode2 = 0 ;
53007 PyObject * obj0 = 0 ;
53008 PyObject * obj1 = 0 ;
53009 char * kwnames[] = {
53010 (char *) "self",(char *) "colspan", NULL
53011 };
53012
53013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53015 if (!SWIG_IsOK(res1)) {
53016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53017 }
53018 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53019 ecode2 = SWIG_AsVal_int(obj1, &val2);
53020 if (!SWIG_IsOK(ecode2)) {
53021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53022 }
53023 arg2 = static_cast< int >(val2);
53024 {
53025 PyThreadState* __tstate = wxPyBeginAllowThreads();
53026 (arg1)->SetColspan(arg2);
53027 wxPyEndAllowThreads(__tstate);
53028 if (PyErr_Occurred()) SWIG_fail;
53029 }
53030 resultobj = SWIG_Py_Void();
53031 return resultobj;
53032 fail:
53033 return NULL;
53034 }
53035
53036
53037 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53038 PyObject *resultobj = 0;
53039 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53040 PyObject *arg2 = (PyObject *) 0 ;
53041 bool result;
53042 void *argp1 = 0 ;
53043 int res1 = 0 ;
53044 PyObject * obj0 = 0 ;
53045 PyObject * obj1 = 0 ;
53046 char * kwnames[] = {
53047 (char *) "self",(char *) "other", NULL
53048 };
53049
53050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53052 if (!SWIG_IsOK(res1)) {
53053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53054 }
53055 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53056 arg2 = obj1;
53057 {
53058 result = (bool)wxGBSpan___eq__(arg1,arg2);
53059 if (PyErr_Occurred()) SWIG_fail;
53060 }
53061 {
53062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53063 }
53064 return resultobj;
53065 fail:
53066 return NULL;
53067 }
53068
53069
53070 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53071 PyObject *resultobj = 0;
53072 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53073 PyObject *arg2 = (PyObject *) 0 ;
53074 bool result;
53075 void *argp1 = 0 ;
53076 int res1 = 0 ;
53077 PyObject * obj0 = 0 ;
53078 PyObject * obj1 = 0 ;
53079 char * kwnames[] = {
53080 (char *) "self",(char *) "other", NULL
53081 };
53082
53083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53085 if (!SWIG_IsOK(res1)) {
53086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53087 }
53088 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53089 arg2 = obj1;
53090 {
53091 result = (bool)wxGBSpan___ne__(arg1,arg2);
53092 if (PyErr_Occurred()) SWIG_fail;
53093 }
53094 {
53095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53096 }
53097 return resultobj;
53098 fail:
53099 return NULL;
53100 }
53101
53102
53103 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53104 PyObject *resultobj = 0;
53105 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53106 int arg2 = (int) 1 ;
53107 int arg3 = (int) 1 ;
53108 void *argp1 = 0 ;
53109 int res1 = 0 ;
53110 int val2 ;
53111 int ecode2 = 0 ;
53112 int val3 ;
53113 int ecode3 = 0 ;
53114 PyObject * obj0 = 0 ;
53115 PyObject * obj1 = 0 ;
53116 PyObject * obj2 = 0 ;
53117 char * kwnames[] = {
53118 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53119 };
53120
53121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53123 if (!SWIG_IsOK(res1)) {
53124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53125 }
53126 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53127 if (obj1) {
53128 ecode2 = SWIG_AsVal_int(obj1, &val2);
53129 if (!SWIG_IsOK(ecode2)) {
53130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53131 }
53132 arg2 = static_cast< int >(val2);
53133 }
53134 if (obj2) {
53135 ecode3 = SWIG_AsVal_int(obj2, &val3);
53136 if (!SWIG_IsOK(ecode3)) {
53137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53138 }
53139 arg3 = static_cast< int >(val3);
53140 }
53141 {
53142 PyThreadState* __tstate = wxPyBeginAllowThreads();
53143 wxGBSpan_Set(arg1,arg2,arg3);
53144 wxPyEndAllowThreads(__tstate);
53145 if (PyErr_Occurred()) SWIG_fail;
53146 }
53147 resultobj = SWIG_Py_Void();
53148 return resultobj;
53149 fail:
53150 return NULL;
53151 }
53152
53153
53154 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53155 PyObject *resultobj = 0;
53156 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53157 PyObject *result = 0 ;
53158 void *argp1 = 0 ;
53159 int res1 = 0 ;
53160 PyObject *swig_obj[1] ;
53161
53162 if (!args) SWIG_fail;
53163 swig_obj[0] = args;
53164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53165 if (!SWIG_IsOK(res1)) {
53166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53167 }
53168 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53169 {
53170 PyThreadState* __tstate = wxPyBeginAllowThreads();
53171 result = (PyObject *)wxGBSpan_Get(arg1);
53172 wxPyEndAllowThreads(__tstate);
53173 if (PyErr_Occurred()) SWIG_fail;
53174 }
53175 resultobj = result;
53176 return resultobj;
53177 fail:
53178 return NULL;
53179 }
53180
53181
53182 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53183 PyObject *obj;
53184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53185 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53186 return SWIG_Py_Void();
53187 }
53188
53189 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53190 return SWIG_Python_InitShadowInstance(args);
53191 }
53192
53193 SWIGINTERN int DefaultSpan_set(PyObject *) {
53194 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53195 return 1;
53196 }
53197
53198
53199 SWIGINTERN PyObject *DefaultSpan_get(void) {
53200 PyObject *pyobj = 0;
53201
53202 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53203 return pyobj;
53204 }
53205
53206
53207 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53208 PyObject *resultobj = 0;
53209 wxGBSizerItem *result = 0 ;
53210
53211 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53212 {
53213 PyThreadState* __tstate = wxPyBeginAllowThreads();
53214 result = (wxGBSizerItem *)new wxGBSizerItem();
53215 wxPyEndAllowThreads(__tstate);
53216 if (PyErr_Occurred()) SWIG_fail;
53217 }
53218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53219 return resultobj;
53220 fail:
53221 return NULL;
53222 }
53223
53224
53225 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53226 PyObject *resultobj = 0;
53227 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53228 void *argp1 = 0 ;
53229 int res1 = 0 ;
53230 PyObject *swig_obj[1] ;
53231
53232 if (!args) SWIG_fail;
53233 swig_obj[0] = args;
53234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53235 if (!SWIG_IsOK(res1)) {
53236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53237 }
53238 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53239 {
53240 PyThreadState* __tstate = wxPyBeginAllowThreads();
53241 delete arg1;
53242
53243 wxPyEndAllowThreads(__tstate);
53244 if (PyErr_Occurred()) SWIG_fail;
53245 }
53246 resultobj = SWIG_Py_Void();
53247 return resultobj;
53248 fail:
53249 return NULL;
53250 }
53251
53252
53253 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53254 PyObject *resultobj = 0;
53255 wxWindow *arg1 = (wxWindow *) 0 ;
53256 wxGBPosition *arg2 = 0 ;
53257 wxGBSpan *arg3 = 0 ;
53258 int arg4 ;
53259 int arg5 ;
53260 PyObject *arg6 = (PyObject *) NULL ;
53261 wxGBSizerItem *result = 0 ;
53262 void *argp1 = 0 ;
53263 int res1 = 0 ;
53264 wxGBPosition temp2 ;
53265 wxGBSpan temp3 ;
53266 int val4 ;
53267 int ecode4 = 0 ;
53268 int val5 ;
53269 int ecode5 = 0 ;
53270 PyObject * obj0 = 0 ;
53271 PyObject * obj1 = 0 ;
53272 PyObject * obj2 = 0 ;
53273 PyObject * obj3 = 0 ;
53274 PyObject * obj4 = 0 ;
53275 PyObject * obj5 = 0 ;
53276 char * kwnames[] = {
53277 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53278 };
53279
53280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53282 if (!SWIG_IsOK(res1)) {
53283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53284 }
53285 arg1 = reinterpret_cast< wxWindow * >(argp1);
53286 {
53287 arg2 = &temp2;
53288 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53289 }
53290 {
53291 arg3 = &temp3;
53292 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53293 }
53294 ecode4 = SWIG_AsVal_int(obj3, &val4);
53295 if (!SWIG_IsOK(ecode4)) {
53296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53297 }
53298 arg4 = static_cast< int >(val4);
53299 ecode5 = SWIG_AsVal_int(obj4, &val5);
53300 if (!SWIG_IsOK(ecode5)) {
53301 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53302 }
53303 arg5 = static_cast< int >(val5);
53304 if (obj5) {
53305 arg6 = obj5;
53306 }
53307 {
53308 PyThreadState* __tstate = wxPyBeginAllowThreads();
53309 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53310 wxPyEndAllowThreads(__tstate);
53311 if (PyErr_Occurred()) SWIG_fail;
53312 }
53313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53314 return resultobj;
53315 fail:
53316 return NULL;
53317 }
53318
53319
53320 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53321 PyObject *resultobj = 0;
53322 wxSizer *arg1 = (wxSizer *) 0 ;
53323 wxGBPosition *arg2 = 0 ;
53324 wxGBSpan *arg3 = 0 ;
53325 int arg4 ;
53326 int arg5 ;
53327 PyObject *arg6 = (PyObject *) NULL ;
53328 wxGBSizerItem *result = 0 ;
53329 int res1 = 0 ;
53330 wxGBPosition temp2 ;
53331 wxGBSpan temp3 ;
53332 int val4 ;
53333 int ecode4 = 0 ;
53334 int val5 ;
53335 int ecode5 = 0 ;
53336 PyObject * obj0 = 0 ;
53337 PyObject * obj1 = 0 ;
53338 PyObject * obj2 = 0 ;
53339 PyObject * obj3 = 0 ;
53340 PyObject * obj4 = 0 ;
53341 PyObject * obj5 = 0 ;
53342 char * kwnames[] = {
53343 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53344 };
53345
53346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53347 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53348 if (!SWIG_IsOK(res1)) {
53349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53350 }
53351 {
53352 arg2 = &temp2;
53353 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53354 }
53355 {
53356 arg3 = &temp3;
53357 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53358 }
53359 ecode4 = SWIG_AsVal_int(obj3, &val4);
53360 if (!SWIG_IsOK(ecode4)) {
53361 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53362 }
53363 arg4 = static_cast< int >(val4);
53364 ecode5 = SWIG_AsVal_int(obj4, &val5);
53365 if (!SWIG_IsOK(ecode5)) {
53366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53367 }
53368 arg5 = static_cast< int >(val5);
53369 if (obj5) {
53370 arg6 = obj5;
53371 }
53372 {
53373 PyThreadState* __tstate = wxPyBeginAllowThreads();
53374 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53375 wxPyEndAllowThreads(__tstate);
53376 if (PyErr_Occurred()) SWIG_fail;
53377 }
53378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53379 return resultobj;
53380 fail:
53381 return NULL;
53382 }
53383
53384
53385 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53386 PyObject *resultobj = 0;
53387 int arg1 ;
53388 int arg2 ;
53389 wxGBPosition *arg3 = 0 ;
53390 wxGBSpan *arg4 = 0 ;
53391 int arg5 ;
53392 int arg6 ;
53393 PyObject *arg7 = (PyObject *) NULL ;
53394 wxGBSizerItem *result = 0 ;
53395 int val1 ;
53396 int ecode1 = 0 ;
53397 int val2 ;
53398 int ecode2 = 0 ;
53399 wxGBPosition temp3 ;
53400 wxGBSpan temp4 ;
53401 int val5 ;
53402 int ecode5 = 0 ;
53403 int val6 ;
53404 int ecode6 = 0 ;
53405 PyObject * obj0 = 0 ;
53406 PyObject * obj1 = 0 ;
53407 PyObject * obj2 = 0 ;
53408 PyObject * obj3 = 0 ;
53409 PyObject * obj4 = 0 ;
53410 PyObject * obj5 = 0 ;
53411 PyObject * obj6 = 0 ;
53412 char * kwnames[] = {
53413 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53414 };
53415
53416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53417 ecode1 = SWIG_AsVal_int(obj0, &val1);
53418 if (!SWIG_IsOK(ecode1)) {
53419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53420 }
53421 arg1 = static_cast< int >(val1);
53422 ecode2 = SWIG_AsVal_int(obj1, &val2);
53423 if (!SWIG_IsOK(ecode2)) {
53424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53425 }
53426 arg2 = static_cast< int >(val2);
53427 {
53428 arg3 = &temp3;
53429 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53430 }
53431 {
53432 arg4 = &temp4;
53433 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53434 }
53435 ecode5 = SWIG_AsVal_int(obj4, &val5);
53436 if (!SWIG_IsOK(ecode5)) {
53437 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53438 }
53439 arg5 = static_cast< int >(val5);
53440 ecode6 = SWIG_AsVal_int(obj5, &val6);
53441 if (!SWIG_IsOK(ecode6)) {
53442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53443 }
53444 arg6 = static_cast< int >(val6);
53445 if (obj6) {
53446 arg7 = obj6;
53447 }
53448 {
53449 PyThreadState* __tstate = wxPyBeginAllowThreads();
53450 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53451 wxPyEndAllowThreads(__tstate);
53452 if (PyErr_Occurred()) SWIG_fail;
53453 }
53454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53455 return resultobj;
53456 fail:
53457 return NULL;
53458 }
53459
53460
53461 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53462 PyObject *resultobj = 0;
53463 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53464 wxGBPosition result;
53465 void *argp1 = 0 ;
53466 int res1 = 0 ;
53467 PyObject *swig_obj[1] ;
53468
53469 if (!args) SWIG_fail;
53470 swig_obj[0] = args;
53471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53472 if (!SWIG_IsOK(res1)) {
53473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53474 }
53475 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53476 {
53477 PyThreadState* __tstate = wxPyBeginAllowThreads();
53478 result = ((wxGBSizerItem const *)arg1)->GetPos();
53479 wxPyEndAllowThreads(__tstate);
53480 if (PyErr_Occurred()) SWIG_fail;
53481 }
53482 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53483 return resultobj;
53484 fail:
53485 return NULL;
53486 }
53487
53488
53489 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53490 PyObject *resultobj = 0;
53491 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53492 wxGBSpan result;
53493 void *argp1 = 0 ;
53494 int res1 = 0 ;
53495 PyObject *swig_obj[1] ;
53496
53497 if (!args) SWIG_fail;
53498 swig_obj[0] = args;
53499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53500 if (!SWIG_IsOK(res1)) {
53501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53502 }
53503 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53504 {
53505 PyThreadState* __tstate = wxPyBeginAllowThreads();
53506 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53507 wxPyEndAllowThreads(__tstate);
53508 if (PyErr_Occurred()) SWIG_fail;
53509 }
53510 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53511 return resultobj;
53512 fail:
53513 return NULL;
53514 }
53515
53516
53517 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53518 PyObject *resultobj = 0;
53519 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53520 wxGBPosition *arg2 = 0 ;
53521 bool result;
53522 void *argp1 = 0 ;
53523 int res1 = 0 ;
53524 wxGBPosition temp2 ;
53525 PyObject * obj0 = 0 ;
53526 PyObject * obj1 = 0 ;
53527 char * kwnames[] = {
53528 (char *) "self",(char *) "pos", NULL
53529 };
53530
53531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53533 if (!SWIG_IsOK(res1)) {
53534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53535 }
53536 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53537 {
53538 arg2 = &temp2;
53539 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53540 }
53541 {
53542 PyThreadState* __tstate = wxPyBeginAllowThreads();
53543 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53544 wxPyEndAllowThreads(__tstate);
53545 if (PyErr_Occurred()) SWIG_fail;
53546 }
53547 {
53548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53549 }
53550 return resultobj;
53551 fail:
53552 return NULL;
53553 }
53554
53555
53556 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53557 PyObject *resultobj = 0;
53558 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53559 wxGBSpan *arg2 = 0 ;
53560 bool result;
53561 void *argp1 = 0 ;
53562 int res1 = 0 ;
53563 wxGBSpan temp2 ;
53564 PyObject * obj0 = 0 ;
53565 PyObject * obj1 = 0 ;
53566 char * kwnames[] = {
53567 (char *) "self",(char *) "span", NULL
53568 };
53569
53570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53572 if (!SWIG_IsOK(res1)) {
53573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53574 }
53575 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53576 {
53577 arg2 = &temp2;
53578 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53579 }
53580 {
53581 PyThreadState* __tstate = wxPyBeginAllowThreads();
53582 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53583 wxPyEndAllowThreads(__tstate);
53584 if (PyErr_Occurred()) SWIG_fail;
53585 }
53586 {
53587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53588 }
53589 return resultobj;
53590 fail:
53591 return NULL;
53592 }
53593
53594
53595 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53596 PyObject *resultobj = 0;
53597 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53598 wxGBSizerItem *arg2 = 0 ;
53599 bool result;
53600 void *argp1 = 0 ;
53601 int res1 = 0 ;
53602 void *argp2 = 0 ;
53603 int res2 = 0 ;
53604 PyObject * obj0 = 0 ;
53605 PyObject * obj1 = 0 ;
53606 char * kwnames[] = {
53607 (char *) "self",(char *) "other", NULL
53608 };
53609
53610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53612 if (!SWIG_IsOK(res1)) {
53613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53614 }
53615 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53616 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53617 if (!SWIG_IsOK(res2)) {
53618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53619 }
53620 if (!argp2) {
53621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53622 }
53623 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53624 {
53625 PyThreadState* __tstate = wxPyBeginAllowThreads();
53626 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53627 wxPyEndAllowThreads(__tstate);
53628 if (PyErr_Occurred()) SWIG_fail;
53629 }
53630 {
53631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53632 }
53633 return resultobj;
53634 fail:
53635 return NULL;
53636 }
53637
53638
53639 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53640 PyObject *resultobj = 0;
53641 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53642 wxGBPosition *arg2 = 0 ;
53643 wxGBSpan *arg3 = 0 ;
53644 bool result;
53645 void *argp1 = 0 ;
53646 int res1 = 0 ;
53647 wxGBPosition temp2 ;
53648 wxGBSpan temp3 ;
53649 PyObject * obj0 = 0 ;
53650 PyObject * obj1 = 0 ;
53651 PyObject * obj2 = 0 ;
53652 char * kwnames[] = {
53653 (char *) "self",(char *) "pos",(char *) "span", NULL
53654 };
53655
53656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53658 if (!SWIG_IsOK(res1)) {
53659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53660 }
53661 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53662 {
53663 arg2 = &temp2;
53664 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53665 }
53666 {
53667 arg3 = &temp3;
53668 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53669 }
53670 {
53671 PyThreadState* __tstate = wxPyBeginAllowThreads();
53672 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53673 wxPyEndAllowThreads(__tstate);
53674 if (PyErr_Occurred()) SWIG_fail;
53675 }
53676 {
53677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53678 }
53679 return resultobj;
53680 fail:
53681 return NULL;
53682 }
53683
53684
53685 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53686 PyObject *resultobj = 0;
53687 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53688 wxGBPosition result;
53689 void *argp1 = 0 ;
53690 int res1 = 0 ;
53691 PyObject *swig_obj[1] ;
53692
53693 if (!args) SWIG_fail;
53694 swig_obj[0] = args;
53695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53696 if (!SWIG_IsOK(res1)) {
53697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53698 }
53699 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53700 {
53701 PyThreadState* __tstate = wxPyBeginAllowThreads();
53702 result = wxGBSizerItem_GetEndPos(arg1);
53703 wxPyEndAllowThreads(__tstate);
53704 if (PyErr_Occurred()) SWIG_fail;
53705 }
53706 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53707 return resultobj;
53708 fail:
53709 return NULL;
53710 }
53711
53712
53713 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53714 PyObject *resultobj = 0;
53715 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53716 wxGridBagSizer *result = 0 ;
53717 void *argp1 = 0 ;
53718 int res1 = 0 ;
53719 PyObject *swig_obj[1] ;
53720
53721 if (!args) SWIG_fail;
53722 swig_obj[0] = args;
53723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53724 if (!SWIG_IsOK(res1)) {
53725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53726 }
53727 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53728 {
53729 PyThreadState* __tstate = wxPyBeginAllowThreads();
53730 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53731 wxPyEndAllowThreads(__tstate);
53732 if (PyErr_Occurred()) SWIG_fail;
53733 }
53734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53735 return resultobj;
53736 fail:
53737 return NULL;
53738 }
53739
53740
53741 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53742 PyObject *resultobj = 0;
53743 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53744 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53745 void *argp1 = 0 ;
53746 int res1 = 0 ;
53747 void *argp2 = 0 ;
53748 int res2 = 0 ;
53749 PyObject * obj0 = 0 ;
53750 PyObject * obj1 = 0 ;
53751 char * kwnames[] = {
53752 (char *) "self",(char *) "sizer", NULL
53753 };
53754
53755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53757 if (!SWIG_IsOK(res1)) {
53758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53759 }
53760 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53762 if (!SWIG_IsOK(res2)) {
53763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53764 }
53765 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53766 {
53767 PyThreadState* __tstate = wxPyBeginAllowThreads();
53768 (arg1)->SetGBSizer(arg2);
53769 wxPyEndAllowThreads(__tstate);
53770 if (PyErr_Occurred()) SWIG_fail;
53771 }
53772 resultobj = SWIG_Py_Void();
53773 return resultobj;
53774 fail:
53775 return NULL;
53776 }
53777
53778
53779 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53780 PyObject *obj;
53781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53782 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53783 return SWIG_Py_Void();
53784 }
53785
53786 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53787 return SWIG_Python_InitShadowInstance(args);
53788 }
53789
53790 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53791 PyObject *resultobj = 0;
53792 int arg1 = (int) 0 ;
53793 int arg2 = (int) 0 ;
53794 wxGridBagSizer *result = 0 ;
53795 int val1 ;
53796 int ecode1 = 0 ;
53797 int val2 ;
53798 int ecode2 = 0 ;
53799 PyObject * obj0 = 0 ;
53800 PyObject * obj1 = 0 ;
53801 char * kwnames[] = {
53802 (char *) "vgap",(char *) "hgap", NULL
53803 };
53804
53805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53806 if (obj0) {
53807 ecode1 = SWIG_AsVal_int(obj0, &val1);
53808 if (!SWIG_IsOK(ecode1)) {
53809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53810 }
53811 arg1 = static_cast< int >(val1);
53812 }
53813 if (obj1) {
53814 ecode2 = SWIG_AsVal_int(obj1, &val2);
53815 if (!SWIG_IsOK(ecode2)) {
53816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53817 }
53818 arg2 = static_cast< int >(val2);
53819 }
53820 {
53821 PyThreadState* __tstate = wxPyBeginAllowThreads();
53822 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53823 wxPyEndAllowThreads(__tstate);
53824 if (PyErr_Occurred()) SWIG_fail;
53825 }
53826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53827 return resultobj;
53828 fail:
53829 return NULL;
53830 }
53831
53832
53833 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53834 PyObject *resultobj = 0;
53835 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53836 PyObject *arg2 = (PyObject *) 0 ;
53837 wxGBPosition *arg3 = 0 ;
53838 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53839 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53840 int arg5 = (int) 0 ;
53841 int arg6 = (int) 0 ;
53842 PyObject *arg7 = (PyObject *) NULL ;
53843 wxGBSizerItem *result = 0 ;
53844 void *argp1 = 0 ;
53845 int res1 = 0 ;
53846 wxGBPosition temp3 ;
53847 wxGBSpan temp4 ;
53848 int val5 ;
53849 int ecode5 = 0 ;
53850 int val6 ;
53851 int ecode6 = 0 ;
53852 PyObject * obj0 = 0 ;
53853 PyObject * obj1 = 0 ;
53854 PyObject * obj2 = 0 ;
53855 PyObject * obj3 = 0 ;
53856 PyObject * obj4 = 0 ;
53857 PyObject * obj5 = 0 ;
53858 PyObject * obj6 = 0 ;
53859 char * kwnames[] = {
53860 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53861 };
53862
53863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53865 if (!SWIG_IsOK(res1)) {
53866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53867 }
53868 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53869 arg2 = obj1;
53870 {
53871 arg3 = &temp3;
53872 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53873 }
53874 if (obj3) {
53875 {
53876 arg4 = &temp4;
53877 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53878 }
53879 }
53880 if (obj4) {
53881 ecode5 = SWIG_AsVal_int(obj4, &val5);
53882 if (!SWIG_IsOK(ecode5)) {
53883 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53884 }
53885 arg5 = static_cast< int >(val5);
53886 }
53887 if (obj5) {
53888 ecode6 = SWIG_AsVal_int(obj5, &val6);
53889 if (!SWIG_IsOK(ecode6)) {
53890 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53891 }
53892 arg6 = static_cast< int >(val6);
53893 }
53894 if (obj6) {
53895 arg7 = obj6;
53896 }
53897 {
53898 PyThreadState* __tstate = wxPyBeginAllowThreads();
53899 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53900 wxPyEndAllowThreads(__tstate);
53901 if (PyErr_Occurred()) SWIG_fail;
53902 }
53903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53904 return resultobj;
53905 fail:
53906 return NULL;
53907 }
53908
53909
53910 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53911 PyObject *resultobj = 0;
53912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53913 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53914 wxGBSizerItem *result = 0 ;
53915 void *argp1 = 0 ;
53916 int res1 = 0 ;
53917 int res2 = 0 ;
53918 PyObject * obj0 = 0 ;
53919 PyObject * obj1 = 0 ;
53920 char * kwnames[] = {
53921 (char *) "self",(char *) "item", NULL
53922 };
53923
53924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53926 if (!SWIG_IsOK(res1)) {
53927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53928 }
53929 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53930 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53931 if (!SWIG_IsOK(res2)) {
53932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53933 }
53934 {
53935 PyThreadState* __tstate = wxPyBeginAllowThreads();
53936 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53937 wxPyEndAllowThreads(__tstate);
53938 if (PyErr_Occurred()) SWIG_fail;
53939 }
53940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53941 return resultobj;
53942 fail:
53943 return NULL;
53944 }
53945
53946
53947 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53948 PyObject *resultobj = 0;
53949 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53950 int arg2 ;
53951 int arg3 ;
53952 wxSize result;
53953 void *argp1 = 0 ;
53954 int res1 = 0 ;
53955 int val2 ;
53956 int ecode2 = 0 ;
53957 int val3 ;
53958 int ecode3 = 0 ;
53959 PyObject * obj0 = 0 ;
53960 PyObject * obj1 = 0 ;
53961 PyObject * obj2 = 0 ;
53962 char * kwnames[] = {
53963 (char *) "self",(char *) "row",(char *) "col", NULL
53964 };
53965
53966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53968 if (!SWIG_IsOK(res1)) {
53969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53970 }
53971 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53972 ecode2 = SWIG_AsVal_int(obj1, &val2);
53973 if (!SWIG_IsOK(ecode2)) {
53974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
53975 }
53976 arg2 = static_cast< int >(val2);
53977 ecode3 = SWIG_AsVal_int(obj2, &val3);
53978 if (!SWIG_IsOK(ecode3)) {
53979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
53980 }
53981 arg3 = static_cast< int >(val3);
53982 {
53983 PyThreadState* __tstate = wxPyBeginAllowThreads();
53984 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
53985 wxPyEndAllowThreads(__tstate);
53986 if (PyErr_Occurred()) SWIG_fail;
53987 }
53988 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
53989 return resultobj;
53990 fail:
53991 return NULL;
53992 }
53993
53994
53995 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53996 PyObject *resultobj = 0;
53997 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53998 wxSize result;
53999 void *argp1 = 0 ;
54000 int res1 = 0 ;
54001 PyObject *swig_obj[1] ;
54002
54003 if (!args) SWIG_fail;
54004 swig_obj[0] = args;
54005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54006 if (!SWIG_IsOK(res1)) {
54007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54008 }
54009 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54010 {
54011 PyThreadState* __tstate = wxPyBeginAllowThreads();
54012 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54013 wxPyEndAllowThreads(__tstate);
54014 if (PyErr_Occurred()) SWIG_fail;
54015 }
54016 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54017 return resultobj;
54018 fail:
54019 return NULL;
54020 }
54021
54022
54023 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54024 PyObject *resultobj = 0;
54025 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54026 wxSize *arg2 = 0 ;
54027 void *argp1 = 0 ;
54028 int res1 = 0 ;
54029 wxSize temp2 ;
54030 PyObject * obj0 = 0 ;
54031 PyObject * obj1 = 0 ;
54032 char * kwnames[] = {
54033 (char *) "self",(char *) "sz", NULL
54034 };
54035
54036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54038 if (!SWIG_IsOK(res1)) {
54039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54040 }
54041 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54042 {
54043 arg2 = &temp2;
54044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54045 }
54046 {
54047 PyThreadState* __tstate = wxPyBeginAllowThreads();
54048 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54049 wxPyEndAllowThreads(__tstate);
54050 if (PyErr_Occurred()) SWIG_fail;
54051 }
54052 resultobj = SWIG_Py_Void();
54053 return resultobj;
54054 fail:
54055 return NULL;
54056 }
54057
54058
54059 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54060 PyObject *resultobj = 0;
54061 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54062 wxWindow *arg2 = (wxWindow *) 0 ;
54063 wxGBPosition result;
54064 void *argp1 = 0 ;
54065 int res1 = 0 ;
54066 void *argp2 = 0 ;
54067 int res2 = 0 ;
54068
54069 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54071 if (!SWIG_IsOK(res1)) {
54072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54073 }
54074 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54075 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54076 if (!SWIG_IsOK(res2)) {
54077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54078 }
54079 arg2 = reinterpret_cast< wxWindow * >(argp2);
54080 {
54081 PyThreadState* __tstate = wxPyBeginAllowThreads();
54082 result = (arg1)->GetItemPosition(arg2);
54083 wxPyEndAllowThreads(__tstate);
54084 if (PyErr_Occurred()) SWIG_fail;
54085 }
54086 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54087 return resultobj;
54088 fail:
54089 return NULL;
54090 }
54091
54092
54093 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54094 PyObject *resultobj = 0;
54095 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54096 wxSizer *arg2 = (wxSizer *) 0 ;
54097 wxGBPosition result;
54098 void *argp1 = 0 ;
54099 int res1 = 0 ;
54100 void *argp2 = 0 ;
54101 int res2 = 0 ;
54102
54103 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54105 if (!SWIG_IsOK(res1)) {
54106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54107 }
54108 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54109 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54110 if (!SWIG_IsOK(res2)) {
54111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54112 }
54113 arg2 = reinterpret_cast< wxSizer * >(argp2);
54114 {
54115 PyThreadState* __tstate = wxPyBeginAllowThreads();
54116 result = (arg1)->GetItemPosition(arg2);
54117 wxPyEndAllowThreads(__tstate);
54118 if (PyErr_Occurred()) SWIG_fail;
54119 }
54120 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54121 return resultobj;
54122 fail:
54123 return NULL;
54124 }
54125
54126
54127 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54128 PyObject *resultobj = 0;
54129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54130 size_t arg2 ;
54131 wxGBPosition result;
54132 void *argp1 = 0 ;
54133 int res1 = 0 ;
54134 size_t val2 ;
54135 int ecode2 = 0 ;
54136
54137 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54139 if (!SWIG_IsOK(res1)) {
54140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54141 }
54142 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54143 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54144 if (!SWIG_IsOK(ecode2)) {
54145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54146 }
54147 arg2 = static_cast< size_t >(val2);
54148 {
54149 PyThreadState* __tstate = wxPyBeginAllowThreads();
54150 result = (arg1)->GetItemPosition(arg2);
54151 wxPyEndAllowThreads(__tstate);
54152 if (PyErr_Occurred()) SWIG_fail;
54153 }
54154 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54155 return resultobj;
54156 fail:
54157 return NULL;
54158 }
54159
54160
54161 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54162 int argc;
54163 PyObject *argv[3];
54164
54165 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54166 --argc;
54167 if (argc == 2) {
54168 int _v = 0;
54169 {
54170 void *vptr = 0;
54171 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54172 _v = SWIG_CheckState(res);
54173 }
54174 if (!_v) goto check_1;
54175 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54176 }
54177 check_1:
54178
54179 if (argc == 2) {
54180 int _v = 0;
54181 {
54182 void *vptr = 0;
54183 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54184 _v = SWIG_CheckState(res);
54185 }
54186 if (!_v) goto check_2;
54187 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54188 }
54189 check_2:
54190
54191 if (argc == 2) {
54192 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54193 }
54194
54195 fail:
54196 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54197 return NULL;
54198 }
54199
54200
54201 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54202 PyObject *resultobj = 0;
54203 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54204 wxWindow *arg2 = (wxWindow *) 0 ;
54205 wxGBPosition *arg3 = 0 ;
54206 bool result;
54207 void *argp1 = 0 ;
54208 int res1 = 0 ;
54209 void *argp2 = 0 ;
54210 int res2 = 0 ;
54211 wxGBPosition temp3 ;
54212
54213 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54215 if (!SWIG_IsOK(res1)) {
54216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54217 }
54218 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54219 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54220 if (!SWIG_IsOK(res2)) {
54221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54222 }
54223 arg2 = reinterpret_cast< wxWindow * >(argp2);
54224 {
54225 arg3 = &temp3;
54226 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54227 }
54228 {
54229 PyThreadState* __tstate = wxPyBeginAllowThreads();
54230 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54231 wxPyEndAllowThreads(__tstate);
54232 if (PyErr_Occurred()) SWIG_fail;
54233 }
54234 {
54235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54236 }
54237 return resultobj;
54238 fail:
54239 return NULL;
54240 }
54241
54242
54243 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54244 PyObject *resultobj = 0;
54245 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54246 wxSizer *arg2 = (wxSizer *) 0 ;
54247 wxGBPosition *arg3 = 0 ;
54248 bool result;
54249 void *argp1 = 0 ;
54250 int res1 = 0 ;
54251 void *argp2 = 0 ;
54252 int res2 = 0 ;
54253 wxGBPosition temp3 ;
54254
54255 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54257 if (!SWIG_IsOK(res1)) {
54258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54259 }
54260 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54261 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54262 if (!SWIG_IsOK(res2)) {
54263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54264 }
54265 arg2 = reinterpret_cast< wxSizer * >(argp2);
54266 {
54267 arg3 = &temp3;
54268 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54269 }
54270 {
54271 PyThreadState* __tstate = wxPyBeginAllowThreads();
54272 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54273 wxPyEndAllowThreads(__tstate);
54274 if (PyErr_Occurred()) SWIG_fail;
54275 }
54276 {
54277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54278 }
54279 return resultobj;
54280 fail:
54281 return NULL;
54282 }
54283
54284
54285 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54286 PyObject *resultobj = 0;
54287 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54288 size_t arg2 ;
54289 wxGBPosition *arg3 = 0 ;
54290 bool result;
54291 void *argp1 = 0 ;
54292 int res1 = 0 ;
54293 size_t val2 ;
54294 int ecode2 = 0 ;
54295 wxGBPosition temp3 ;
54296
54297 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54299 if (!SWIG_IsOK(res1)) {
54300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54301 }
54302 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54303 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54304 if (!SWIG_IsOK(ecode2)) {
54305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54306 }
54307 arg2 = static_cast< size_t >(val2);
54308 {
54309 arg3 = &temp3;
54310 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54311 }
54312 {
54313 PyThreadState* __tstate = wxPyBeginAllowThreads();
54314 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54315 wxPyEndAllowThreads(__tstate);
54316 if (PyErr_Occurred()) SWIG_fail;
54317 }
54318 {
54319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54320 }
54321 return resultobj;
54322 fail:
54323 return NULL;
54324 }
54325
54326
54327 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54328 int argc;
54329 PyObject *argv[4];
54330
54331 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54332 --argc;
54333 if (argc == 3) {
54334 int _v = 0;
54335 {
54336 void *vptr = 0;
54337 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54338 _v = SWIG_CheckState(res);
54339 }
54340 if (!_v) goto check_1;
54341 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54342 }
54343 check_1:
54344
54345 if (argc == 3) {
54346 int _v = 0;
54347 {
54348 void *vptr = 0;
54349 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54350 _v = SWIG_CheckState(res);
54351 }
54352 if (!_v) goto check_2;
54353 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54354 }
54355 check_2:
54356
54357 if (argc == 3) {
54358 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54359 }
54360
54361 fail:
54362 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54363 return NULL;
54364 }
54365
54366
54367 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54368 PyObject *resultobj = 0;
54369 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54370 wxWindow *arg2 = (wxWindow *) 0 ;
54371 wxGBSpan result;
54372 void *argp1 = 0 ;
54373 int res1 = 0 ;
54374 void *argp2 = 0 ;
54375 int res2 = 0 ;
54376
54377 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54379 if (!SWIG_IsOK(res1)) {
54380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54381 }
54382 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54383 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54384 if (!SWIG_IsOK(res2)) {
54385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54386 }
54387 arg2 = reinterpret_cast< wxWindow * >(argp2);
54388 {
54389 PyThreadState* __tstate = wxPyBeginAllowThreads();
54390 result = (arg1)->GetItemSpan(arg2);
54391 wxPyEndAllowThreads(__tstate);
54392 if (PyErr_Occurred()) SWIG_fail;
54393 }
54394 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54395 return resultobj;
54396 fail:
54397 return NULL;
54398 }
54399
54400
54401 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54402 PyObject *resultobj = 0;
54403 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54404 wxSizer *arg2 = (wxSizer *) 0 ;
54405 wxGBSpan result;
54406 void *argp1 = 0 ;
54407 int res1 = 0 ;
54408 void *argp2 = 0 ;
54409 int res2 = 0 ;
54410
54411 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54413 if (!SWIG_IsOK(res1)) {
54414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54415 }
54416 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54417 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54418 if (!SWIG_IsOK(res2)) {
54419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54420 }
54421 arg2 = reinterpret_cast< wxSizer * >(argp2);
54422 {
54423 PyThreadState* __tstate = wxPyBeginAllowThreads();
54424 result = (arg1)->GetItemSpan(arg2);
54425 wxPyEndAllowThreads(__tstate);
54426 if (PyErr_Occurred()) SWIG_fail;
54427 }
54428 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54429 return resultobj;
54430 fail:
54431 return NULL;
54432 }
54433
54434
54435 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54436 PyObject *resultobj = 0;
54437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54438 size_t arg2 ;
54439 wxGBSpan result;
54440 void *argp1 = 0 ;
54441 int res1 = 0 ;
54442 size_t val2 ;
54443 int ecode2 = 0 ;
54444
54445 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54447 if (!SWIG_IsOK(res1)) {
54448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54449 }
54450 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54451 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54452 if (!SWIG_IsOK(ecode2)) {
54453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54454 }
54455 arg2 = static_cast< size_t >(val2);
54456 {
54457 PyThreadState* __tstate = wxPyBeginAllowThreads();
54458 result = (arg1)->GetItemSpan(arg2);
54459 wxPyEndAllowThreads(__tstate);
54460 if (PyErr_Occurred()) SWIG_fail;
54461 }
54462 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54463 return resultobj;
54464 fail:
54465 return NULL;
54466 }
54467
54468
54469 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54470 int argc;
54471 PyObject *argv[3];
54472
54473 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54474 --argc;
54475 if (argc == 2) {
54476 int _v = 0;
54477 {
54478 void *vptr = 0;
54479 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54480 _v = SWIG_CheckState(res);
54481 }
54482 if (!_v) goto check_1;
54483 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54484 }
54485 check_1:
54486
54487 if (argc == 2) {
54488 int _v = 0;
54489 {
54490 void *vptr = 0;
54491 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54492 _v = SWIG_CheckState(res);
54493 }
54494 if (!_v) goto check_2;
54495 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54496 }
54497 check_2:
54498
54499 if (argc == 2) {
54500 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54501 }
54502
54503 fail:
54504 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54505 return NULL;
54506 }
54507
54508
54509 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54510 PyObject *resultobj = 0;
54511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54512 wxWindow *arg2 = (wxWindow *) 0 ;
54513 wxGBSpan *arg3 = 0 ;
54514 bool result;
54515 void *argp1 = 0 ;
54516 int res1 = 0 ;
54517 void *argp2 = 0 ;
54518 int res2 = 0 ;
54519 wxGBSpan temp3 ;
54520
54521 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54523 if (!SWIG_IsOK(res1)) {
54524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54525 }
54526 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54527 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54528 if (!SWIG_IsOK(res2)) {
54529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54530 }
54531 arg2 = reinterpret_cast< wxWindow * >(argp2);
54532 {
54533 arg3 = &temp3;
54534 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54535 }
54536 {
54537 PyThreadState* __tstate = wxPyBeginAllowThreads();
54538 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54539 wxPyEndAllowThreads(__tstate);
54540 if (PyErr_Occurred()) SWIG_fail;
54541 }
54542 {
54543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54544 }
54545 return resultobj;
54546 fail:
54547 return NULL;
54548 }
54549
54550
54551 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54552 PyObject *resultobj = 0;
54553 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54554 wxSizer *arg2 = (wxSizer *) 0 ;
54555 wxGBSpan *arg3 = 0 ;
54556 bool result;
54557 void *argp1 = 0 ;
54558 int res1 = 0 ;
54559 void *argp2 = 0 ;
54560 int res2 = 0 ;
54561 wxGBSpan temp3 ;
54562
54563 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54565 if (!SWIG_IsOK(res1)) {
54566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54567 }
54568 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54569 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54570 if (!SWIG_IsOK(res2)) {
54571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54572 }
54573 arg2 = reinterpret_cast< wxSizer * >(argp2);
54574 {
54575 arg3 = &temp3;
54576 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54577 }
54578 {
54579 PyThreadState* __tstate = wxPyBeginAllowThreads();
54580 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54581 wxPyEndAllowThreads(__tstate);
54582 if (PyErr_Occurred()) SWIG_fail;
54583 }
54584 {
54585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54586 }
54587 return resultobj;
54588 fail:
54589 return NULL;
54590 }
54591
54592
54593 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54594 PyObject *resultobj = 0;
54595 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54596 size_t arg2 ;
54597 wxGBSpan *arg3 = 0 ;
54598 bool result;
54599 void *argp1 = 0 ;
54600 int res1 = 0 ;
54601 size_t val2 ;
54602 int ecode2 = 0 ;
54603 wxGBSpan temp3 ;
54604
54605 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54607 if (!SWIG_IsOK(res1)) {
54608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54609 }
54610 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54611 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54612 if (!SWIG_IsOK(ecode2)) {
54613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54614 }
54615 arg2 = static_cast< size_t >(val2);
54616 {
54617 arg3 = &temp3;
54618 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54619 }
54620 {
54621 PyThreadState* __tstate = wxPyBeginAllowThreads();
54622 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54623 wxPyEndAllowThreads(__tstate);
54624 if (PyErr_Occurred()) SWIG_fail;
54625 }
54626 {
54627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54628 }
54629 return resultobj;
54630 fail:
54631 return NULL;
54632 }
54633
54634
54635 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54636 int argc;
54637 PyObject *argv[4];
54638
54639 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54640 --argc;
54641 if (argc == 3) {
54642 int _v = 0;
54643 {
54644 void *vptr = 0;
54645 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54646 _v = SWIG_CheckState(res);
54647 }
54648 if (!_v) goto check_1;
54649 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54650 }
54651 check_1:
54652
54653 if (argc == 3) {
54654 int _v = 0;
54655 {
54656 void *vptr = 0;
54657 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54658 _v = SWIG_CheckState(res);
54659 }
54660 if (!_v) goto check_2;
54661 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54662 }
54663 check_2:
54664
54665 if (argc == 3) {
54666 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54667 }
54668
54669 fail:
54670 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54671 return NULL;
54672 }
54673
54674
54675 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54676 PyObject *resultobj = 0;
54677 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54678 wxWindow *arg2 = (wxWindow *) 0 ;
54679 wxGBSizerItem *result = 0 ;
54680 void *argp1 = 0 ;
54681 int res1 = 0 ;
54682 void *argp2 = 0 ;
54683 int res2 = 0 ;
54684
54685 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54687 if (!SWIG_IsOK(res1)) {
54688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54689 }
54690 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54691 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54692 if (!SWIG_IsOK(res2)) {
54693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54694 }
54695 arg2 = reinterpret_cast< wxWindow * >(argp2);
54696 {
54697 PyThreadState* __tstate = wxPyBeginAllowThreads();
54698 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54699 wxPyEndAllowThreads(__tstate);
54700 if (PyErr_Occurred()) SWIG_fail;
54701 }
54702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54703 return resultobj;
54704 fail:
54705 return NULL;
54706 }
54707
54708
54709 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54710 PyObject *resultobj = 0;
54711 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54712 wxSizer *arg2 = (wxSizer *) 0 ;
54713 wxGBSizerItem *result = 0 ;
54714 void *argp1 = 0 ;
54715 int res1 = 0 ;
54716 void *argp2 = 0 ;
54717 int res2 = 0 ;
54718
54719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54721 if (!SWIG_IsOK(res1)) {
54722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54723 }
54724 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54726 if (!SWIG_IsOK(res2)) {
54727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54728 }
54729 arg2 = reinterpret_cast< wxSizer * >(argp2);
54730 {
54731 PyThreadState* __tstate = wxPyBeginAllowThreads();
54732 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54733 wxPyEndAllowThreads(__tstate);
54734 if (PyErr_Occurred()) SWIG_fail;
54735 }
54736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54737 return resultobj;
54738 fail:
54739 return NULL;
54740 }
54741
54742
54743 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54744 int argc;
54745 PyObject *argv[3];
54746
54747 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54748 --argc;
54749 if (argc == 2) {
54750 int _v = 0;
54751 {
54752 void *vptr = 0;
54753 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54754 _v = SWIG_CheckState(res);
54755 }
54756 if (!_v) goto check_1;
54757 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54758 }
54759 check_1:
54760
54761 if (argc == 2) {
54762 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54763 }
54764
54765 fail:
54766 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54767 return NULL;
54768 }
54769
54770
54771 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54772 PyObject *resultobj = 0;
54773 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54774 wxGBPosition *arg2 = 0 ;
54775 wxGBSizerItem *result = 0 ;
54776 void *argp1 = 0 ;
54777 int res1 = 0 ;
54778 wxGBPosition temp2 ;
54779 PyObject * obj0 = 0 ;
54780 PyObject * obj1 = 0 ;
54781 char * kwnames[] = {
54782 (char *) "self",(char *) "pos", NULL
54783 };
54784
54785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54787 if (!SWIG_IsOK(res1)) {
54788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54789 }
54790 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54791 {
54792 arg2 = &temp2;
54793 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54794 }
54795 {
54796 PyThreadState* __tstate = wxPyBeginAllowThreads();
54797 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54798 wxPyEndAllowThreads(__tstate);
54799 if (PyErr_Occurred()) SWIG_fail;
54800 }
54801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54802 return resultobj;
54803 fail:
54804 return NULL;
54805 }
54806
54807
54808 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54809 PyObject *resultobj = 0;
54810 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54811 wxPoint *arg2 = 0 ;
54812 wxGBSizerItem *result = 0 ;
54813 void *argp1 = 0 ;
54814 int res1 = 0 ;
54815 wxPoint temp2 ;
54816 PyObject * obj0 = 0 ;
54817 PyObject * obj1 = 0 ;
54818 char * kwnames[] = {
54819 (char *) "self",(char *) "pt", NULL
54820 };
54821
54822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54824 if (!SWIG_IsOK(res1)) {
54825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54826 }
54827 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54828 {
54829 arg2 = &temp2;
54830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54831 }
54832 {
54833 PyThreadState* __tstate = wxPyBeginAllowThreads();
54834 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54835 wxPyEndAllowThreads(__tstate);
54836 if (PyErr_Occurred()) SWIG_fail;
54837 }
54838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54839 return resultobj;
54840 fail:
54841 return NULL;
54842 }
54843
54844
54845 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54846 PyObject *resultobj = 0;
54847 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54848 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54849 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54850 bool result;
54851 void *argp1 = 0 ;
54852 int res1 = 0 ;
54853 void *argp2 = 0 ;
54854 int res2 = 0 ;
54855 void *argp3 = 0 ;
54856 int res3 = 0 ;
54857 PyObject * obj0 = 0 ;
54858 PyObject * obj1 = 0 ;
54859 PyObject * obj2 = 0 ;
54860 char * kwnames[] = {
54861 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54862 };
54863
54864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54866 if (!SWIG_IsOK(res1)) {
54867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54868 }
54869 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54871 if (!SWIG_IsOK(res2)) {
54872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54873 }
54874 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54875 if (obj2) {
54876 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54877 if (!SWIG_IsOK(res3)) {
54878 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54879 }
54880 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54881 }
54882 {
54883 PyThreadState* __tstate = wxPyBeginAllowThreads();
54884 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54885 wxPyEndAllowThreads(__tstate);
54886 if (PyErr_Occurred()) SWIG_fail;
54887 }
54888 {
54889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54890 }
54891 return resultobj;
54892 fail:
54893 return NULL;
54894 }
54895
54896
54897 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54898 PyObject *resultobj = 0;
54899 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54900 wxGBPosition *arg2 = 0 ;
54901 wxGBSpan *arg3 = 0 ;
54902 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54903 bool result;
54904 void *argp1 = 0 ;
54905 int res1 = 0 ;
54906 wxGBPosition temp2 ;
54907 wxGBSpan temp3 ;
54908 void *argp4 = 0 ;
54909 int res4 = 0 ;
54910 PyObject * obj0 = 0 ;
54911 PyObject * obj1 = 0 ;
54912 PyObject * obj2 = 0 ;
54913 PyObject * obj3 = 0 ;
54914 char * kwnames[] = {
54915 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54916 };
54917
54918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54920 if (!SWIG_IsOK(res1)) {
54921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54922 }
54923 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54924 {
54925 arg2 = &temp2;
54926 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54927 }
54928 {
54929 arg3 = &temp3;
54930 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54931 }
54932 if (obj3) {
54933 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54934 if (!SWIG_IsOK(res4)) {
54935 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54936 }
54937 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54938 }
54939 {
54940 PyThreadState* __tstate = wxPyBeginAllowThreads();
54941 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54942 wxPyEndAllowThreads(__tstate);
54943 if (PyErr_Occurred()) SWIG_fail;
54944 }
54945 {
54946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54947 }
54948 return resultobj;
54949 fail:
54950 return NULL;
54951 }
54952
54953
54954 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54955 PyObject *obj;
54956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54957 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54958 return SWIG_Py_Void();
54959 }
54960
54961 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54962 return SWIG_Python_InitShadowInstance(args);
54963 }
54964
54965 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54966 PyObject *resultobj = 0;
54967 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54968 wxRelationship arg2 ;
54969 wxWindow *arg3 = (wxWindow *) 0 ;
54970 wxEdge arg4 ;
54971 int arg5 = (int) 0 ;
54972 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
54973 void *argp1 = 0 ;
54974 int res1 = 0 ;
54975 int val2 ;
54976 int ecode2 = 0 ;
54977 void *argp3 = 0 ;
54978 int res3 = 0 ;
54979 int val4 ;
54980 int ecode4 = 0 ;
54981 int val5 ;
54982 int ecode5 = 0 ;
54983 int val6 ;
54984 int ecode6 = 0 ;
54985 PyObject * obj0 = 0 ;
54986 PyObject * obj1 = 0 ;
54987 PyObject * obj2 = 0 ;
54988 PyObject * obj3 = 0 ;
54989 PyObject * obj4 = 0 ;
54990 PyObject * obj5 = 0 ;
54991 char * kwnames[] = {
54992 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
54993 };
54994
54995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54997 if (!SWIG_IsOK(res1)) {
54998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
54999 }
55000 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55001 ecode2 = SWIG_AsVal_int(obj1, &val2);
55002 if (!SWIG_IsOK(ecode2)) {
55003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55004 }
55005 arg2 = static_cast< wxRelationship >(val2);
55006 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55007 if (!SWIG_IsOK(res3)) {
55008 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55009 }
55010 arg3 = reinterpret_cast< wxWindow * >(argp3);
55011 ecode4 = SWIG_AsVal_int(obj3, &val4);
55012 if (!SWIG_IsOK(ecode4)) {
55013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55014 }
55015 arg4 = static_cast< wxEdge >(val4);
55016 if (obj4) {
55017 ecode5 = SWIG_AsVal_int(obj4, &val5);
55018 if (!SWIG_IsOK(ecode5)) {
55019 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55020 }
55021 arg5 = static_cast< int >(val5);
55022 }
55023 if (obj5) {
55024 ecode6 = SWIG_AsVal_int(obj5, &val6);
55025 if (!SWIG_IsOK(ecode6)) {
55026 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55027 }
55028 arg6 = static_cast< int >(val6);
55029 }
55030 {
55031 PyThreadState* __tstate = wxPyBeginAllowThreads();
55032 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55033 wxPyEndAllowThreads(__tstate);
55034 if (PyErr_Occurred()) SWIG_fail;
55035 }
55036 resultobj = SWIG_Py_Void();
55037 return resultobj;
55038 fail:
55039 return NULL;
55040 }
55041
55042
55043 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55044 PyObject *resultobj = 0;
55045 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55046 wxWindow *arg2 = (wxWindow *) 0 ;
55047 int arg3 = (int) 0 ;
55048 void *argp1 = 0 ;
55049 int res1 = 0 ;
55050 void *argp2 = 0 ;
55051 int res2 = 0 ;
55052 int val3 ;
55053 int ecode3 = 0 ;
55054 PyObject * obj0 = 0 ;
55055 PyObject * obj1 = 0 ;
55056 PyObject * obj2 = 0 ;
55057 char * kwnames[] = {
55058 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55059 };
55060
55061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55063 if (!SWIG_IsOK(res1)) {
55064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55065 }
55066 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55068 if (!SWIG_IsOK(res2)) {
55069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55070 }
55071 arg2 = reinterpret_cast< wxWindow * >(argp2);
55072 if (obj2) {
55073 ecode3 = SWIG_AsVal_int(obj2, &val3);
55074 if (!SWIG_IsOK(ecode3)) {
55075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55076 }
55077 arg3 = static_cast< int >(val3);
55078 }
55079 {
55080 PyThreadState* __tstate = wxPyBeginAllowThreads();
55081 (arg1)->LeftOf(arg2,arg3);
55082 wxPyEndAllowThreads(__tstate);
55083 if (PyErr_Occurred()) SWIG_fail;
55084 }
55085 resultobj = SWIG_Py_Void();
55086 return resultobj;
55087 fail:
55088 return NULL;
55089 }
55090
55091
55092 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55093 PyObject *resultobj = 0;
55094 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55095 wxWindow *arg2 = (wxWindow *) 0 ;
55096 int arg3 = (int) 0 ;
55097 void *argp1 = 0 ;
55098 int res1 = 0 ;
55099 void *argp2 = 0 ;
55100 int res2 = 0 ;
55101 int val3 ;
55102 int ecode3 = 0 ;
55103 PyObject * obj0 = 0 ;
55104 PyObject * obj1 = 0 ;
55105 PyObject * obj2 = 0 ;
55106 char * kwnames[] = {
55107 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55108 };
55109
55110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55112 if (!SWIG_IsOK(res1)) {
55113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55114 }
55115 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55117 if (!SWIG_IsOK(res2)) {
55118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55119 }
55120 arg2 = reinterpret_cast< wxWindow * >(argp2);
55121 if (obj2) {
55122 ecode3 = SWIG_AsVal_int(obj2, &val3);
55123 if (!SWIG_IsOK(ecode3)) {
55124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55125 }
55126 arg3 = static_cast< int >(val3);
55127 }
55128 {
55129 PyThreadState* __tstate = wxPyBeginAllowThreads();
55130 (arg1)->RightOf(arg2,arg3);
55131 wxPyEndAllowThreads(__tstate);
55132 if (PyErr_Occurred()) SWIG_fail;
55133 }
55134 resultobj = SWIG_Py_Void();
55135 return resultobj;
55136 fail:
55137 return NULL;
55138 }
55139
55140
55141 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55142 PyObject *resultobj = 0;
55143 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55144 wxWindow *arg2 = (wxWindow *) 0 ;
55145 int arg3 = (int) 0 ;
55146 void *argp1 = 0 ;
55147 int res1 = 0 ;
55148 void *argp2 = 0 ;
55149 int res2 = 0 ;
55150 int val3 ;
55151 int ecode3 = 0 ;
55152 PyObject * obj0 = 0 ;
55153 PyObject * obj1 = 0 ;
55154 PyObject * obj2 = 0 ;
55155 char * kwnames[] = {
55156 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55157 };
55158
55159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55161 if (!SWIG_IsOK(res1)) {
55162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55163 }
55164 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55166 if (!SWIG_IsOK(res2)) {
55167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55168 }
55169 arg2 = reinterpret_cast< wxWindow * >(argp2);
55170 if (obj2) {
55171 ecode3 = SWIG_AsVal_int(obj2, &val3);
55172 if (!SWIG_IsOK(ecode3)) {
55173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55174 }
55175 arg3 = static_cast< int >(val3);
55176 }
55177 {
55178 PyThreadState* __tstate = wxPyBeginAllowThreads();
55179 (arg1)->Above(arg2,arg3);
55180 wxPyEndAllowThreads(__tstate);
55181 if (PyErr_Occurred()) SWIG_fail;
55182 }
55183 resultobj = SWIG_Py_Void();
55184 return resultobj;
55185 fail:
55186 return NULL;
55187 }
55188
55189
55190 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55191 PyObject *resultobj = 0;
55192 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55193 wxWindow *arg2 = (wxWindow *) 0 ;
55194 int arg3 = (int) 0 ;
55195 void *argp1 = 0 ;
55196 int res1 = 0 ;
55197 void *argp2 = 0 ;
55198 int res2 = 0 ;
55199 int val3 ;
55200 int ecode3 = 0 ;
55201 PyObject * obj0 = 0 ;
55202 PyObject * obj1 = 0 ;
55203 PyObject * obj2 = 0 ;
55204 char * kwnames[] = {
55205 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55206 };
55207
55208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55210 if (!SWIG_IsOK(res1)) {
55211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55212 }
55213 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55214 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55215 if (!SWIG_IsOK(res2)) {
55216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55217 }
55218 arg2 = reinterpret_cast< wxWindow * >(argp2);
55219 if (obj2) {
55220 ecode3 = SWIG_AsVal_int(obj2, &val3);
55221 if (!SWIG_IsOK(ecode3)) {
55222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55223 }
55224 arg3 = static_cast< int >(val3);
55225 }
55226 {
55227 PyThreadState* __tstate = wxPyBeginAllowThreads();
55228 (arg1)->Below(arg2,arg3);
55229 wxPyEndAllowThreads(__tstate);
55230 if (PyErr_Occurred()) SWIG_fail;
55231 }
55232 resultobj = SWIG_Py_Void();
55233 return resultobj;
55234 fail:
55235 return NULL;
55236 }
55237
55238
55239 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55240 PyObject *resultobj = 0;
55241 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55242 wxWindow *arg2 = (wxWindow *) 0 ;
55243 wxEdge arg3 ;
55244 int arg4 = (int) 0 ;
55245 void *argp1 = 0 ;
55246 int res1 = 0 ;
55247 void *argp2 = 0 ;
55248 int res2 = 0 ;
55249 int val3 ;
55250 int ecode3 = 0 ;
55251 int val4 ;
55252 int ecode4 = 0 ;
55253 PyObject * obj0 = 0 ;
55254 PyObject * obj1 = 0 ;
55255 PyObject * obj2 = 0 ;
55256 PyObject * obj3 = 0 ;
55257 char * kwnames[] = {
55258 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55259 };
55260
55261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55263 if (!SWIG_IsOK(res1)) {
55264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55265 }
55266 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55268 if (!SWIG_IsOK(res2)) {
55269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55270 }
55271 arg2 = reinterpret_cast< wxWindow * >(argp2);
55272 ecode3 = SWIG_AsVal_int(obj2, &val3);
55273 if (!SWIG_IsOK(ecode3)) {
55274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55275 }
55276 arg3 = static_cast< wxEdge >(val3);
55277 if (obj3) {
55278 ecode4 = SWIG_AsVal_int(obj3, &val4);
55279 if (!SWIG_IsOK(ecode4)) {
55280 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55281 }
55282 arg4 = static_cast< int >(val4);
55283 }
55284 {
55285 PyThreadState* __tstate = wxPyBeginAllowThreads();
55286 (arg1)->SameAs(arg2,arg3,arg4);
55287 wxPyEndAllowThreads(__tstate);
55288 if (PyErr_Occurred()) SWIG_fail;
55289 }
55290 resultobj = SWIG_Py_Void();
55291 return resultobj;
55292 fail:
55293 return NULL;
55294 }
55295
55296
55297 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55298 PyObject *resultobj = 0;
55299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55300 wxWindow *arg2 = (wxWindow *) 0 ;
55301 wxEdge arg3 ;
55302 int arg4 ;
55303 void *argp1 = 0 ;
55304 int res1 = 0 ;
55305 void *argp2 = 0 ;
55306 int res2 = 0 ;
55307 int val3 ;
55308 int ecode3 = 0 ;
55309 int val4 ;
55310 int ecode4 = 0 ;
55311 PyObject * obj0 = 0 ;
55312 PyObject * obj1 = 0 ;
55313 PyObject * obj2 = 0 ;
55314 PyObject * obj3 = 0 ;
55315 char * kwnames[] = {
55316 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55317 };
55318
55319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55321 if (!SWIG_IsOK(res1)) {
55322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55323 }
55324 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55326 if (!SWIG_IsOK(res2)) {
55327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55328 }
55329 arg2 = reinterpret_cast< wxWindow * >(argp2);
55330 ecode3 = SWIG_AsVal_int(obj2, &val3);
55331 if (!SWIG_IsOK(ecode3)) {
55332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55333 }
55334 arg3 = static_cast< wxEdge >(val3);
55335 ecode4 = SWIG_AsVal_int(obj3, &val4);
55336 if (!SWIG_IsOK(ecode4)) {
55337 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55338 }
55339 arg4 = static_cast< int >(val4);
55340 {
55341 PyThreadState* __tstate = wxPyBeginAllowThreads();
55342 (arg1)->PercentOf(arg2,arg3,arg4);
55343 wxPyEndAllowThreads(__tstate);
55344 if (PyErr_Occurred()) SWIG_fail;
55345 }
55346 resultobj = SWIG_Py_Void();
55347 return resultobj;
55348 fail:
55349 return NULL;
55350 }
55351
55352
55353 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55354 PyObject *resultobj = 0;
55355 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55356 int arg2 ;
55357 void *argp1 = 0 ;
55358 int res1 = 0 ;
55359 int val2 ;
55360 int ecode2 = 0 ;
55361 PyObject * obj0 = 0 ;
55362 PyObject * obj1 = 0 ;
55363 char * kwnames[] = {
55364 (char *) "self",(char *) "val", NULL
55365 };
55366
55367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55369 if (!SWIG_IsOK(res1)) {
55370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55371 }
55372 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55373 ecode2 = SWIG_AsVal_int(obj1, &val2);
55374 if (!SWIG_IsOK(ecode2)) {
55375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55376 }
55377 arg2 = static_cast< int >(val2);
55378 {
55379 PyThreadState* __tstate = wxPyBeginAllowThreads();
55380 (arg1)->Absolute(arg2);
55381 wxPyEndAllowThreads(__tstate);
55382 if (PyErr_Occurred()) SWIG_fail;
55383 }
55384 resultobj = SWIG_Py_Void();
55385 return resultobj;
55386 fail:
55387 return NULL;
55388 }
55389
55390
55391 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55392 PyObject *resultobj = 0;
55393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55394 void *argp1 = 0 ;
55395 int res1 = 0 ;
55396 PyObject *swig_obj[1] ;
55397
55398 if (!args) SWIG_fail;
55399 swig_obj[0] = args;
55400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55401 if (!SWIG_IsOK(res1)) {
55402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55403 }
55404 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55405 {
55406 PyThreadState* __tstate = wxPyBeginAllowThreads();
55407 (arg1)->Unconstrained();
55408 wxPyEndAllowThreads(__tstate);
55409 if (PyErr_Occurred()) SWIG_fail;
55410 }
55411 resultobj = SWIG_Py_Void();
55412 return resultobj;
55413 fail:
55414 return NULL;
55415 }
55416
55417
55418 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55419 PyObject *resultobj = 0;
55420 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55421 void *argp1 = 0 ;
55422 int res1 = 0 ;
55423 PyObject *swig_obj[1] ;
55424
55425 if (!args) SWIG_fail;
55426 swig_obj[0] = args;
55427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55428 if (!SWIG_IsOK(res1)) {
55429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55430 }
55431 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55432 {
55433 PyThreadState* __tstate = wxPyBeginAllowThreads();
55434 (arg1)->AsIs();
55435 wxPyEndAllowThreads(__tstate);
55436 if (PyErr_Occurred()) SWIG_fail;
55437 }
55438 resultobj = SWIG_Py_Void();
55439 return resultobj;
55440 fail:
55441 return NULL;
55442 }
55443
55444
55445 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55446 PyObject *resultobj = 0;
55447 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55448 wxWindow *result = 0 ;
55449 void *argp1 = 0 ;
55450 int res1 = 0 ;
55451 PyObject *swig_obj[1] ;
55452
55453 if (!args) SWIG_fail;
55454 swig_obj[0] = args;
55455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55456 if (!SWIG_IsOK(res1)) {
55457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55458 }
55459 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55460 {
55461 PyThreadState* __tstate = wxPyBeginAllowThreads();
55462 result = (wxWindow *)(arg1)->GetOtherWindow();
55463 wxPyEndAllowThreads(__tstate);
55464 if (PyErr_Occurred()) SWIG_fail;
55465 }
55466 {
55467 resultobj = wxPyMake_wxObject(result, 0);
55468 }
55469 return resultobj;
55470 fail:
55471 return NULL;
55472 }
55473
55474
55475 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55476 PyObject *resultobj = 0;
55477 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55478 wxEdge result;
55479 void *argp1 = 0 ;
55480 int res1 = 0 ;
55481 PyObject *swig_obj[1] ;
55482
55483 if (!args) SWIG_fail;
55484 swig_obj[0] = args;
55485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55486 if (!SWIG_IsOK(res1)) {
55487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55488 }
55489 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55490 {
55491 PyThreadState* __tstate = wxPyBeginAllowThreads();
55492 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55493 wxPyEndAllowThreads(__tstate);
55494 if (PyErr_Occurred()) SWIG_fail;
55495 }
55496 resultobj = SWIG_From_int(static_cast< int >(result));
55497 return resultobj;
55498 fail:
55499 return NULL;
55500 }
55501
55502
55503 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55504 PyObject *resultobj = 0;
55505 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55506 wxEdge arg2 ;
55507 void *argp1 = 0 ;
55508 int res1 = 0 ;
55509 int val2 ;
55510 int ecode2 = 0 ;
55511 PyObject * obj0 = 0 ;
55512 PyObject * obj1 = 0 ;
55513 char * kwnames[] = {
55514 (char *) "self",(char *) "which", NULL
55515 };
55516
55517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55519 if (!SWIG_IsOK(res1)) {
55520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55521 }
55522 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55523 ecode2 = SWIG_AsVal_int(obj1, &val2);
55524 if (!SWIG_IsOK(ecode2)) {
55525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55526 }
55527 arg2 = static_cast< wxEdge >(val2);
55528 {
55529 PyThreadState* __tstate = wxPyBeginAllowThreads();
55530 (arg1)->SetEdge(arg2);
55531 wxPyEndAllowThreads(__tstate);
55532 if (PyErr_Occurred()) SWIG_fail;
55533 }
55534 resultobj = SWIG_Py_Void();
55535 return resultobj;
55536 fail:
55537 return NULL;
55538 }
55539
55540
55541 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55542 PyObject *resultobj = 0;
55543 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55544 int arg2 ;
55545 void *argp1 = 0 ;
55546 int res1 = 0 ;
55547 int val2 ;
55548 int ecode2 = 0 ;
55549 PyObject * obj0 = 0 ;
55550 PyObject * obj1 = 0 ;
55551 char * kwnames[] = {
55552 (char *) "self",(char *) "v", NULL
55553 };
55554
55555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55557 if (!SWIG_IsOK(res1)) {
55558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55559 }
55560 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55561 ecode2 = SWIG_AsVal_int(obj1, &val2);
55562 if (!SWIG_IsOK(ecode2)) {
55563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55564 }
55565 arg2 = static_cast< int >(val2);
55566 {
55567 PyThreadState* __tstate = wxPyBeginAllowThreads();
55568 (arg1)->SetValue(arg2);
55569 wxPyEndAllowThreads(__tstate);
55570 if (PyErr_Occurred()) SWIG_fail;
55571 }
55572 resultobj = SWIG_Py_Void();
55573 return resultobj;
55574 fail:
55575 return NULL;
55576 }
55577
55578
55579 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55580 PyObject *resultobj = 0;
55581 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55582 int result;
55583 void *argp1 = 0 ;
55584 int res1 = 0 ;
55585 PyObject *swig_obj[1] ;
55586
55587 if (!args) SWIG_fail;
55588 swig_obj[0] = args;
55589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55590 if (!SWIG_IsOK(res1)) {
55591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55592 }
55593 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55594 {
55595 PyThreadState* __tstate = wxPyBeginAllowThreads();
55596 result = (int)(arg1)->GetMargin();
55597 wxPyEndAllowThreads(__tstate);
55598 if (PyErr_Occurred()) SWIG_fail;
55599 }
55600 resultobj = SWIG_From_int(static_cast< int >(result));
55601 return resultobj;
55602 fail:
55603 return NULL;
55604 }
55605
55606
55607 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55608 PyObject *resultobj = 0;
55609 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55610 int arg2 ;
55611 void *argp1 = 0 ;
55612 int res1 = 0 ;
55613 int val2 ;
55614 int ecode2 = 0 ;
55615 PyObject * obj0 = 0 ;
55616 PyObject * obj1 = 0 ;
55617 char * kwnames[] = {
55618 (char *) "self",(char *) "m", NULL
55619 };
55620
55621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55623 if (!SWIG_IsOK(res1)) {
55624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55625 }
55626 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55627 ecode2 = SWIG_AsVal_int(obj1, &val2);
55628 if (!SWIG_IsOK(ecode2)) {
55629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55630 }
55631 arg2 = static_cast< int >(val2);
55632 {
55633 PyThreadState* __tstate = wxPyBeginAllowThreads();
55634 (arg1)->SetMargin(arg2);
55635 wxPyEndAllowThreads(__tstate);
55636 if (PyErr_Occurred()) SWIG_fail;
55637 }
55638 resultobj = SWIG_Py_Void();
55639 return resultobj;
55640 fail:
55641 return NULL;
55642 }
55643
55644
55645 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55646 PyObject *resultobj = 0;
55647 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55648 int result;
55649 void *argp1 = 0 ;
55650 int res1 = 0 ;
55651 PyObject *swig_obj[1] ;
55652
55653 if (!args) SWIG_fail;
55654 swig_obj[0] = args;
55655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55656 if (!SWIG_IsOK(res1)) {
55657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55658 }
55659 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55660 {
55661 PyThreadState* __tstate = wxPyBeginAllowThreads();
55662 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55663 wxPyEndAllowThreads(__tstate);
55664 if (PyErr_Occurred()) SWIG_fail;
55665 }
55666 resultobj = SWIG_From_int(static_cast< int >(result));
55667 return resultobj;
55668 fail:
55669 return NULL;
55670 }
55671
55672
55673 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55674 PyObject *resultobj = 0;
55675 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55676 int result;
55677 void *argp1 = 0 ;
55678 int res1 = 0 ;
55679 PyObject *swig_obj[1] ;
55680
55681 if (!args) SWIG_fail;
55682 swig_obj[0] = args;
55683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55684 if (!SWIG_IsOK(res1)) {
55685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55686 }
55687 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55688 {
55689 PyThreadState* __tstate = wxPyBeginAllowThreads();
55690 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55691 wxPyEndAllowThreads(__tstate);
55692 if (PyErr_Occurred()) SWIG_fail;
55693 }
55694 resultobj = SWIG_From_int(static_cast< int >(result));
55695 return resultobj;
55696 fail:
55697 return NULL;
55698 }
55699
55700
55701 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55702 PyObject *resultobj = 0;
55703 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55704 int result;
55705 void *argp1 = 0 ;
55706 int res1 = 0 ;
55707 PyObject *swig_obj[1] ;
55708
55709 if (!args) SWIG_fail;
55710 swig_obj[0] = args;
55711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55712 if (!SWIG_IsOK(res1)) {
55713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55714 }
55715 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55716 {
55717 PyThreadState* __tstate = wxPyBeginAllowThreads();
55718 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55719 wxPyEndAllowThreads(__tstate);
55720 if (PyErr_Occurred()) SWIG_fail;
55721 }
55722 resultobj = SWIG_From_int(static_cast< int >(result));
55723 return resultobj;
55724 fail:
55725 return NULL;
55726 }
55727
55728
55729 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55730 PyObject *resultobj = 0;
55731 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55732 bool result;
55733 void *argp1 = 0 ;
55734 int res1 = 0 ;
55735 PyObject *swig_obj[1] ;
55736
55737 if (!args) SWIG_fail;
55738 swig_obj[0] = args;
55739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55740 if (!SWIG_IsOK(res1)) {
55741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55742 }
55743 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55744 {
55745 PyThreadState* __tstate = wxPyBeginAllowThreads();
55746 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55747 wxPyEndAllowThreads(__tstate);
55748 if (PyErr_Occurred()) SWIG_fail;
55749 }
55750 {
55751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55752 }
55753 return resultobj;
55754 fail:
55755 return NULL;
55756 }
55757
55758
55759 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55760 PyObject *resultobj = 0;
55761 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55762 bool arg2 ;
55763 void *argp1 = 0 ;
55764 int res1 = 0 ;
55765 bool val2 ;
55766 int ecode2 = 0 ;
55767 PyObject * obj0 = 0 ;
55768 PyObject * obj1 = 0 ;
55769 char * kwnames[] = {
55770 (char *) "self",(char *) "d", NULL
55771 };
55772
55773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55775 if (!SWIG_IsOK(res1)) {
55776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55777 }
55778 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55780 if (!SWIG_IsOK(ecode2)) {
55781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55782 }
55783 arg2 = static_cast< bool >(val2);
55784 {
55785 PyThreadState* __tstate = wxPyBeginAllowThreads();
55786 (arg1)->SetDone(arg2);
55787 wxPyEndAllowThreads(__tstate);
55788 if (PyErr_Occurred()) SWIG_fail;
55789 }
55790 resultobj = SWIG_Py_Void();
55791 return resultobj;
55792 fail:
55793 return NULL;
55794 }
55795
55796
55797 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55798 PyObject *resultobj = 0;
55799 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55800 wxRelationship result;
55801 void *argp1 = 0 ;
55802 int res1 = 0 ;
55803 PyObject *swig_obj[1] ;
55804
55805 if (!args) SWIG_fail;
55806 swig_obj[0] = args;
55807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55808 if (!SWIG_IsOK(res1)) {
55809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55810 }
55811 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55812 {
55813 PyThreadState* __tstate = wxPyBeginAllowThreads();
55814 result = (wxRelationship)(arg1)->GetRelationship();
55815 wxPyEndAllowThreads(__tstate);
55816 if (PyErr_Occurred()) SWIG_fail;
55817 }
55818 resultobj = SWIG_From_int(static_cast< int >(result));
55819 return resultobj;
55820 fail:
55821 return NULL;
55822 }
55823
55824
55825 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55826 PyObject *resultobj = 0;
55827 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55828 wxRelationship arg2 ;
55829 void *argp1 = 0 ;
55830 int res1 = 0 ;
55831 int val2 ;
55832 int ecode2 = 0 ;
55833 PyObject * obj0 = 0 ;
55834 PyObject * obj1 = 0 ;
55835 char * kwnames[] = {
55836 (char *) "self",(char *) "r", NULL
55837 };
55838
55839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55841 if (!SWIG_IsOK(res1)) {
55842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55843 }
55844 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55845 ecode2 = SWIG_AsVal_int(obj1, &val2);
55846 if (!SWIG_IsOK(ecode2)) {
55847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55848 }
55849 arg2 = static_cast< wxRelationship >(val2);
55850 {
55851 PyThreadState* __tstate = wxPyBeginAllowThreads();
55852 (arg1)->SetRelationship(arg2);
55853 wxPyEndAllowThreads(__tstate);
55854 if (PyErr_Occurred()) SWIG_fail;
55855 }
55856 resultobj = SWIG_Py_Void();
55857 return resultobj;
55858 fail:
55859 return NULL;
55860 }
55861
55862
55863 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55864 PyObject *resultobj = 0;
55865 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55866 wxWindow *arg2 = (wxWindow *) 0 ;
55867 bool result;
55868 void *argp1 = 0 ;
55869 int res1 = 0 ;
55870 void *argp2 = 0 ;
55871 int res2 = 0 ;
55872 PyObject * obj0 = 0 ;
55873 PyObject * obj1 = 0 ;
55874 char * kwnames[] = {
55875 (char *) "self",(char *) "otherW", NULL
55876 };
55877
55878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55880 if (!SWIG_IsOK(res1)) {
55881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55882 }
55883 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55884 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55885 if (!SWIG_IsOK(res2)) {
55886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55887 }
55888 arg2 = reinterpret_cast< wxWindow * >(argp2);
55889 {
55890 PyThreadState* __tstate = wxPyBeginAllowThreads();
55891 result = (bool)(arg1)->ResetIfWin(arg2);
55892 wxPyEndAllowThreads(__tstate);
55893 if (PyErr_Occurred()) SWIG_fail;
55894 }
55895 {
55896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55897 }
55898 return resultobj;
55899 fail:
55900 return NULL;
55901 }
55902
55903
55904 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55905 PyObject *resultobj = 0;
55906 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55907 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55908 wxWindow *arg3 = (wxWindow *) 0 ;
55909 bool result;
55910 void *argp1 = 0 ;
55911 int res1 = 0 ;
55912 void *argp2 = 0 ;
55913 int res2 = 0 ;
55914 void *argp3 = 0 ;
55915 int res3 = 0 ;
55916 PyObject * obj0 = 0 ;
55917 PyObject * obj1 = 0 ;
55918 PyObject * obj2 = 0 ;
55919 char * kwnames[] = {
55920 (char *) "self",(char *) "constraints",(char *) "win", NULL
55921 };
55922
55923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55925 if (!SWIG_IsOK(res1)) {
55926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55927 }
55928 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55929 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55930 if (!SWIG_IsOK(res2)) {
55931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55932 }
55933 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55934 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55935 if (!SWIG_IsOK(res3)) {
55936 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55937 }
55938 arg3 = reinterpret_cast< wxWindow * >(argp3);
55939 {
55940 PyThreadState* __tstate = wxPyBeginAllowThreads();
55941 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55942 wxPyEndAllowThreads(__tstate);
55943 if (PyErr_Occurred()) SWIG_fail;
55944 }
55945 {
55946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55947 }
55948 return resultobj;
55949 fail:
55950 return NULL;
55951 }
55952
55953
55954 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55955 PyObject *resultobj = 0;
55956 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55957 wxEdge arg2 ;
55958 wxWindow *arg3 = (wxWindow *) 0 ;
55959 wxWindow *arg4 = (wxWindow *) 0 ;
55960 int result;
55961 void *argp1 = 0 ;
55962 int res1 = 0 ;
55963 int val2 ;
55964 int ecode2 = 0 ;
55965 void *argp3 = 0 ;
55966 int res3 = 0 ;
55967 void *argp4 = 0 ;
55968 int res4 = 0 ;
55969 PyObject * obj0 = 0 ;
55970 PyObject * obj1 = 0 ;
55971 PyObject * obj2 = 0 ;
55972 PyObject * obj3 = 0 ;
55973 char * kwnames[] = {
55974 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
55975 };
55976
55977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55979 if (!SWIG_IsOK(res1)) {
55980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55981 }
55982 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55983 ecode2 = SWIG_AsVal_int(obj1, &val2);
55984 if (!SWIG_IsOK(ecode2)) {
55985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55986 }
55987 arg2 = static_cast< wxEdge >(val2);
55988 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55989 if (!SWIG_IsOK(res3)) {
55990 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
55991 }
55992 arg3 = reinterpret_cast< wxWindow * >(argp3);
55993 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
55994 if (!SWIG_IsOK(res4)) {
55995 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
55996 }
55997 arg4 = reinterpret_cast< wxWindow * >(argp4);
55998 {
55999 PyThreadState* __tstate = wxPyBeginAllowThreads();
56000 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56001 wxPyEndAllowThreads(__tstate);
56002 if (PyErr_Occurred()) SWIG_fail;
56003 }
56004 resultobj = SWIG_From_int(static_cast< int >(result));
56005 return resultobj;
56006 fail:
56007 return NULL;
56008 }
56009
56010
56011 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56012 PyObject *obj;
56013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56014 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56015 return SWIG_Py_Void();
56016 }
56017
56018 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56019 PyObject *resultobj = 0;
56020 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56021 wxIndividualLayoutConstraint *result = 0 ;
56022 void *argp1 = 0 ;
56023 int res1 = 0 ;
56024 PyObject *swig_obj[1] ;
56025
56026 if (!args) SWIG_fail;
56027 swig_obj[0] = args;
56028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56029 if (!SWIG_IsOK(res1)) {
56030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56031 }
56032 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56033 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56035 return resultobj;
56036 fail:
56037 return NULL;
56038 }
56039
56040
56041 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56042 PyObject *resultobj = 0;
56043 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56044 wxIndividualLayoutConstraint *result = 0 ;
56045 void *argp1 = 0 ;
56046 int res1 = 0 ;
56047 PyObject *swig_obj[1] ;
56048
56049 if (!args) SWIG_fail;
56050 swig_obj[0] = args;
56051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56052 if (!SWIG_IsOK(res1)) {
56053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56054 }
56055 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56056 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56058 return resultobj;
56059 fail:
56060 return NULL;
56061 }
56062
56063
56064 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56065 PyObject *resultobj = 0;
56066 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56067 wxIndividualLayoutConstraint *result = 0 ;
56068 void *argp1 = 0 ;
56069 int res1 = 0 ;
56070 PyObject *swig_obj[1] ;
56071
56072 if (!args) SWIG_fail;
56073 swig_obj[0] = args;
56074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56075 if (!SWIG_IsOK(res1)) {
56076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56077 }
56078 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56079 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56081 return resultobj;
56082 fail:
56083 return NULL;
56084 }
56085
56086
56087 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56088 PyObject *resultobj = 0;
56089 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56090 wxIndividualLayoutConstraint *result = 0 ;
56091 void *argp1 = 0 ;
56092 int res1 = 0 ;
56093 PyObject *swig_obj[1] ;
56094
56095 if (!args) SWIG_fail;
56096 swig_obj[0] = args;
56097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56098 if (!SWIG_IsOK(res1)) {
56099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56100 }
56101 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56102 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56104 return resultobj;
56105 fail:
56106 return NULL;
56107 }
56108
56109
56110 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56111 PyObject *resultobj = 0;
56112 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56113 wxIndividualLayoutConstraint *result = 0 ;
56114 void *argp1 = 0 ;
56115 int res1 = 0 ;
56116 PyObject *swig_obj[1] ;
56117
56118 if (!args) SWIG_fail;
56119 swig_obj[0] = args;
56120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56121 if (!SWIG_IsOK(res1)) {
56122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56123 }
56124 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56125 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56127 return resultobj;
56128 fail:
56129 return NULL;
56130 }
56131
56132
56133 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56134 PyObject *resultobj = 0;
56135 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56136 wxIndividualLayoutConstraint *result = 0 ;
56137 void *argp1 = 0 ;
56138 int res1 = 0 ;
56139 PyObject *swig_obj[1] ;
56140
56141 if (!args) SWIG_fail;
56142 swig_obj[0] = args;
56143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56144 if (!SWIG_IsOK(res1)) {
56145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56146 }
56147 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56148 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56150 return resultobj;
56151 fail:
56152 return NULL;
56153 }
56154
56155
56156 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56157 PyObject *resultobj = 0;
56158 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56159 wxIndividualLayoutConstraint *result = 0 ;
56160 void *argp1 = 0 ;
56161 int res1 = 0 ;
56162 PyObject *swig_obj[1] ;
56163
56164 if (!args) SWIG_fail;
56165 swig_obj[0] = args;
56166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56167 if (!SWIG_IsOK(res1)) {
56168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56169 }
56170 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56171 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56173 return resultobj;
56174 fail:
56175 return NULL;
56176 }
56177
56178
56179 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56180 PyObject *resultobj = 0;
56181 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56182 wxIndividualLayoutConstraint *result = 0 ;
56183 void *argp1 = 0 ;
56184 int res1 = 0 ;
56185 PyObject *swig_obj[1] ;
56186
56187 if (!args) SWIG_fail;
56188 swig_obj[0] = args;
56189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56190 if (!SWIG_IsOK(res1)) {
56191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56192 }
56193 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56194 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56196 return resultobj;
56197 fail:
56198 return NULL;
56199 }
56200
56201
56202 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56203 PyObject *resultobj = 0;
56204 wxLayoutConstraints *result = 0 ;
56205
56206 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56207 {
56208 PyThreadState* __tstate = wxPyBeginAllowThreads();
56209 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56210 wxPyEndAllowThreads(__tstate);
56211 if (PyErr_Occurred()) SWIG_fail;
56212 }
56213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56214 return resultobj;
56215 fail:
56216 return NULL;
56217 }
56218
56219
56220 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56221 PyObject *resultobj = 0;
56222 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56223 void *argp1 = 0 ;
56224 int res1 = 0 ;
56225 PyObject *swig_obj[1] ;
56226
56227 if (!args) SWIG_fail;
56228 swig_obj[0] = args;
56229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56230 if (!SWIG_IsOK(res1)) {
56231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56232 }
56233 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56234 {
56235 PyThreadState* __tstate = wxPyBeginAllowThreads();
56236 delete arg1;
56237
56238 wxPyEndAllowThreads(__tstate);
56239 if (PyErr_Occurred()) SWIG_fail;
56240 }
56241 resultobj = SWIG_Py_Void();
56242 return resultobj;
56243 fail:
56244 return NULL;
56245 }
56246
56247
56248 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56249 PyObject *resultobj = 0;
56250 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56251 wxWindow *arg2 = (wxWindow *) 0 ;
56252 int *arg3 = (int *) 0 ;
56253 bool result;
56254 void *argp1 = 0 ;
56255 int res1 = 0 ;
56256 void *argp2 = 0 ;
56257 int res2 = 0 ;
56258 int temp3 ;
56259 int res3 = SWIG_TMPOBJ ;
56260 PyObject * obj0 = 0 ;
56261 PyObject * obj1 = 0 ;
56262 char * kwnames[] = {
56263 (char *) "self",(char *) "win", NULL
56264 };
56265
56266 arg3 = &temp3;
56267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56269 if (!SWIG_IsOK(res1)) {
56270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56271 }
56272 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56274 if (!SWIG_IsOK(res2)) {
56275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56276 }
56277 arg2 = reinterpret_cast< wxWindow * >(argp2);
56278 {
56279 PyThreadState* __tstate = wxPyBeginAllowThreads();
56280 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56281 wxPyEndAllowThreads(__tstate);
56282 if (PyErr_Occurred()) SWIG_fail;
56283 }
56284 {
56285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56286 }
56287 if (SWIG_IsTmpObj(res3)) {
56288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56289 } else {
56290 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56292 }
56293 return resultobj;
56294 fail:
56295 return NULL;
56296 }
56297
56298
56299 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56300 PyObject *resultobj = 0;
56301 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56302 bool result;
56303 void *argp1 = 0 ;
56304 int res1 = 0 ;
56305 PyObject *swig_obj[1] ;
56306
56307 if (!args) SWIG_fail;
56308 swig_obj[0] = args;
56309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56310 if (!SWIG_IsOK(res1)) {
56311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56312 }
56313 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56314 {
56315 PyThreadState* __tstate = wxPyBeginAllowThreads();
56316 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56317 wxPyEndAllowThreads(__tstate);
56318 if (PyErr_Occurred()) SWIG_fail;
56319 }
56320 {
56321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56322 }
56323 return resultobj;
56324 fail:
56325 return NULL;
56326 }
56327
56328
56329 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56330 PyObject *obj;
56331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56332 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56333 return SWIG_Py_Void();
56334 }
56335
56336 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56337 return SWIG_Python_InitShadowInstance(args);
56338 }
56339
56340 static PyMethodDef SwigMethods[] = {
56341 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56342 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56343 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56344 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56345 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56346 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56347 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56348 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56349 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56350 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56351 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56352 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56353 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56354 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56355 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56356 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56357 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56358 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56359 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56360 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56361 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56362 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56363 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56364 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56365 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56366 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56367 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56368 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56369 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56370 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56371 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56372 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56373 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56374 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56375 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56376 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56377 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56378 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56379 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56380 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56381 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56382 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56383 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56384 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56385 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56386 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56387 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56388 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56389 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56390 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56391 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56392 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56393 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56394 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56395 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56396 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56397 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56398 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56399 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56400 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56401 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56402 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56403 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56404 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56405 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56406 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56407 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56409 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56410 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56411 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56412 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56413 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56414 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56415 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56416 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56417 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56418 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56419 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56420 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56422 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56423 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56424 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56425 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56426 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56427 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56428 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56429 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56430 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56431 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56432 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56433 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56434 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56442 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56443 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56451 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56452 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56453 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56454 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56455 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56456 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56457 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56458 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56460 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56461 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56462 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56467 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56468 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56469 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56470 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56471 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56478 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56485 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56486 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56487 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56488 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56490 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56491 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56492 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56494 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56495 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56496 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56497 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56500 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56503 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56506 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56509 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56512 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56515 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56518 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56521 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56527 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56529 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56538 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56541 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56542 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56543 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56544 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56545 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56546 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56547 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56548 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56550 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56551 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56552 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56554 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56555 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56556 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56557 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56562 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56563 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56564 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56565 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56566 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56567 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56570 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56571 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56572 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56574 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56575 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56577 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56578 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56579 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56580 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56581 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56582 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56583 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56584 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56585 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56586 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56587 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56588 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56593 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56599 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56600 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56601 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56602 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56604 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56607 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56610 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56613 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56614 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56615 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56618 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56619 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56620 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56624 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56625 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56626 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56630 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56635 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56636 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56637 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56638 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56639 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56640 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56641 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56648 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56649 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56651 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56652 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56653 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56659 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56660 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56662 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56663 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56664 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56665 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56666 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56667 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56668 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56669 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56671 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56672 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56673 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56674 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56675 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56676 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56677 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56678 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56680 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56681 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56689 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56706 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56707 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56722 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56723 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56724 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56725 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56728 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56730 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56732 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56734 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56736 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56739 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56740 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56741 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56742 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56744 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56761 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56762 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56768 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56769 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56771 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56772 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56773 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56774 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56775 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56776 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56777 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56778 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56779 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56780 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56781 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56782 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56783 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56784 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56785 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56786 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56787 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56788 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56789 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56790 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56791 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56792 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56793 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56794 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56795 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56796 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56797 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56798 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56799 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56800 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56801 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56802 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56803 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56804 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56805 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56806 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56808 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56809 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56810 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56811 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56814 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56818 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56822 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56823 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56824 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56825 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56827 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56828 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56830 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56832 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56834 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56836 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56837 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56838 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56840 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56841 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56843 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56844 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56845 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56847 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56848 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56849 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56851 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56853 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56854 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56855 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56857 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56859 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56860 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56862 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56863 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56864 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56866 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56867 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56868 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56869 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56870 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56872 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56873 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56876 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56877 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56879 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56880 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56883 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56884 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56886 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56887 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56891 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56892 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56893 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56894 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56895 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56896 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56897 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56898 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56899 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56900 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56901 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56902 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56903 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56904 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56905 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56906 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56907 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56908 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56909 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56910 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56911 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56912 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56913 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56914 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56915 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56917 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56918 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56919 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56920 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56921 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56922 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56923 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56924 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56925 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56926 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56927 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56928 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56929 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56930 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56931 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56932 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56933 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56934 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56935 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56936 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56937 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56938 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56939 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56940 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56941 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56942 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56943 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56944 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56945 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56946 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56947 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56948 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56950 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56951 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56952 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56953 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56954 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56955 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56956 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56958 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56959 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56960 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56961 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56962 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56963 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56964 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56965 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56966 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56968 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56969 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56970 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56971 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
56972 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
56973 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
56974 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
56975 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
56976 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
56977 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
56978 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
56979 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
56980 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
56981 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
56982 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
56983 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
56984 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
56985 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
56986 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
56987 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
56988 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
56989 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
56990 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
56991 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
56992 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
56993 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
56994 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
56995 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56996 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
56997 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
56998 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
56999 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57000 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57001 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57002 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57003 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57004 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57005 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57006 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57007 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57008 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57009 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57010 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57011 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57012 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57013 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57014 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57015 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57016 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57017 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57018 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57019 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57021 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57022 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57023 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57024 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57025 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57026 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57027 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57028 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57029 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57030 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57031 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57032 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57033 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57034 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57035 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57036 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57037 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57038 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57039 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57041 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57042 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57043 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57044 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57045 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57046 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57047 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57048 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57049 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57050 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57051 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57052 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57053 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57054 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57055 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57056 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57057 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57058 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57059 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57061 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57062 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57063 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57064 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57065 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57066 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57067 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57068 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57069 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57070 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57071 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57072 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57073 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57074 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57075 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57076 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57077 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57078 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57079 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57080 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57081 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57085 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57087 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57088 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57089 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57090 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57091 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57092 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57093 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57094 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57095 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57096 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57097 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57098 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57100 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57101 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57102 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57105 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57106 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57107 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57108 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57109 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57110 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57112 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57113 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57114 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57115 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57116 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57117 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57118 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57120 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57121 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57123 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57125 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57126 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57128 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57129 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57130 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57132 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57133 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57134 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57135 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57136 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57138 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57139 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57140 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57141 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57142 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57144 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57145 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57146 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57147 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57149 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57150 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57151 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57152 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57154 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57155 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57156 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57158 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57160 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57161 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57162 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57164 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57165 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57166 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57167 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57168 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57169 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57170 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57171 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57172 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57173 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57174 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57175 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57176 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57177 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57178 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57180 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57181 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57182 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57183 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57184 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57185 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57186 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57187 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57188 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57190 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57192 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57194 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57195 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57196 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57197 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57198 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57199 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57200 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57201 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57202 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57203 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57204 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57205 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57206 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57211 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57212 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57213 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57214 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57215 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57216 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57217 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57218 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57220 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57222 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57223 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57225 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57226 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57227 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57228 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57229 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57230 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57231 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57232 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57233 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57235 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57236 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57237 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57238 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57239 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57240 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57241 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57242 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57243 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57245 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57246 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57247 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57248 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57249 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57251 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57252 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57254 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57255 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57256 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57257 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57259 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57260 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57261 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57262 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57263 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57264 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57265 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57266 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57267 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57268 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57270 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57273 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57274 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57275 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57277 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57279 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57281 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57283 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57284 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57287 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57290 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57296 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57297 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57298 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57302 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57303 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57304 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57305 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57306 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57307 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57308 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57309 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57310 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57311 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57312 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57313 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57314 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57315 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57316 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57318 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57319 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57321 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57322 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57325 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57327 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57328 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57329 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57330 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57331 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57332 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57333 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57334 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57335 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57337 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57338 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57339 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57341 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57342 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57343 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57344 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57345 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57346 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57348 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57350 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57352 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57355 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57356 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57357 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57358 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57359 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57360 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57364 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57365 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57366 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57367 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57374 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57380 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57381 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57382 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57383 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57384 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57386 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57396 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57397 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57398 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57399 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57402 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57403 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57404 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57405 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57406 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57408 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57409 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57410 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57411 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57414 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57420 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57421 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57422 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57423 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57425 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57426 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57428 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57431 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57433 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57434 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57435 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57436 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57444 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57448 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57449 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57451 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57461 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57462 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57463 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57464 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57468 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57471 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57473 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57476 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57478 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57479 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57482 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57484 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57485 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57486 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57487 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57489 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57490 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57495 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57496 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57497 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57499 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57500 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57501 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57503 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57505 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57506 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57507 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57509 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57510 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57513 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57521 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57528 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57536 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57539 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57540 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57553 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57555 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57557 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57558 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57560 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57562 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57563 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57565 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57566 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57567 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57571 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57590 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57591 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57593 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57594 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57596 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57597 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57598 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57600 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57601 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57604 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57605 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57607 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57608 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57610 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57613 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57614 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57616 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57618 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57620 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57621 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57623 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57624 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57627 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57629 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57631 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57633 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57636 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57638 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57639 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57640 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57642 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57643 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57644 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57646 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57648 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57649 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57652 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57653 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57657 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57661 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57662 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57664 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57668 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57670 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57672 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57673 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57674 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57675 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57679 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57680 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57681 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57682 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57684 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57685 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57690 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57691 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57692 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57693 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57694 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57696 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57698 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57700 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57701 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57703 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57705 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57708 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57709 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57710 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57712 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57713 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57714 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57727 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57733 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57734 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57735 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57736 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57737 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57738 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57744 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57745 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57749 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57750 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57752 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57753 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57755 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57757 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57758 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57760 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57761 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57762 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57768 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57769 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57770 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57771 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57772 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57773 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57780 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57782 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57783 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57784 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57785 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57786 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57787 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57789 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57793 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57794 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57795 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57796 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57797 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57798 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57799 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57801 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57802 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57803 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57809 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57810 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57811 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57813 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57814 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57815 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57821 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57822 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57823 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57824 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57825 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57829 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57830 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57835 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57836 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57838 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57839 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57844 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57846 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57847 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57848 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57849 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57850 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57855 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57856 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57865 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57866 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57867 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57868 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57871 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57873 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57874 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57875 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57876 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57878 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57883 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57884 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57885 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57886 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57887 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57888 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57889 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57890 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57891 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57892 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57893 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57895 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57896 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57897 { NULL, NULL, 0, NULL }
57898 };
57899
57900
57901 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57902
57903 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57904 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57905 }
57906 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57907 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57908 }
57909 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57910 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57911 }
57912 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57913 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57914 }
57915 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57916 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57917 }
57918 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57919 return (void *)((wxSizer *) ((wxGridSizer *) x));
57920 }
57921 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57922 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57923 }
57924 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57925 return (void *)((wxSizer *) ((wxPySizer *) x));
57926 }
57927 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57928 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57929 }
57930 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57931 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57932 }
57933 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57934 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57935 }
57936 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57937 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57938 }
57939 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57940 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57941 }
57942 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57943 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57944 }
57945 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57946 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57947 }
57948 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57949 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57950 }
57951 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57952 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57953 }
57954 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57955 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57956 }
57957 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57958 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57959 }
57960 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57961 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57962 }
57963 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57964 return (void *)((wxEvent *) ((wxPyEvent *) x));
57965 }
57966 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57967 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57968 }
57969 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57970 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
57971 }
57972 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
57973 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
57974 }
57975 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
57976 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
57977 }
57978 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
57979 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
57980 }
57981 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
57982 return (void *)((wxEvent *) ((wxActivateEvent *) x));
57983 }
57984 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
57985 return (void *)((wxEvent *) ((wxSizeEvent *) x));
57986 }
57987 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
57988 return (void *)((wxEvent *) ((wxMoveEvent *) x));
57989 }
57990 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
57991 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
57992 }
57993 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
57994 return (void *)((wxEvent *) ((wxPaintEvent *) x));
57995 }
57996 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
57997 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
57998 }
57999 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58000 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58001 }
58002 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58003 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58004 }
58005 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58006 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58007 }
58008 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58009 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58010 }
58011 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58012 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58013 }
58014 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58015 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58016 }
58017 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58018 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58019 }
58020 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58021 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58022 }
58023 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58024 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58025 }
58026 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58027 return (void *)((wxEvent *) ((wxShowEvent *) x));
58028 }
58029 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58030 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58031 }
58032 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58033 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58034 }
58035 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58037 }
58038 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58039 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58040 }
58041 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58042 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58043 }
58044 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58045 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58046 }
58047 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58048 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58049 }
58050 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58051 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58052 }
58053 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58054 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58055 }
58056 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58057 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58058 }
58059 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58060 return (void *)((wxControl *) ((wxControlWithItems *) x));
58061 }
58062 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58063 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58064 }
58065 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58066 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58067 }
58068 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58069 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58070 }
58071 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58072 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58073 }
58074 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58075 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58076 }
58077 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58078 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58079 }
58080 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58081 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58082 }
58083 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58084 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58085 }
58086 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58087 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58088 }
58089 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58090 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58091 }
58092 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58093 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58094 }
58095 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58096 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58097 }
58098 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58099 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58100 }
58101 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58102 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58103 }
58104 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58105 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58106 }
58107 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58108 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58109 }
58110 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58111 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58112 }
58113 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58114 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58115 }
58116 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58117 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58118 }
58119 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58120 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58121 }
58122 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58123 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58124 }
58125 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58126 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58127 }
58128 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58129 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58130 }
58131 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58132 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58133 }
58134 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58135 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58136 }
58137 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58138 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58139 }
58140 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58141 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58142 }
58143 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58144 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58145 }
58146 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58147 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58148 }
58149 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58150 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58151 }
58152 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58153 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58154 }
58155 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58156 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58157 }
58158 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58159 return (void *)((wxObject *) ((wxSizerItem *) x));
58160 }
58161 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58162 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58163 }
58164 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58165 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58166 }
58167 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58168 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58169 }
58170 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58171 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58172 }
58173 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58174 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58175 }
58176 static void *_p_wxSizerTo_p_wxObject(void *x) {
58177 return (void *)((wxObject *) ((wxSizer *) x));
58178 }
58179 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58180 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58181 }
58182 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58183 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58184 }
58185 static void *_p_wxEventTo_p_wxObject(void *x) {
58186 return (void *)((wxObject *) ((wxEvent *) x));
58187 }
58188 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58189 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58190 }
58191 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58192 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58193 }
58194 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58195 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58196 }
58197 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58198 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58199 }
58200 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58201 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58202 }
58203 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58204 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58205 }
58206 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58207 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58208 }
58209 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58210 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58211 }
58212 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58213 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58214 }
58215 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58216 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58217 }
58218 static void *_p_wxControlTo_p_wxObject(void *x) {
58219 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58220 }
58221 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58222 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58223 }
58224 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58225 return (void *)((wxObject *) ((wxFSFile *) x));
58226 }
58227 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58228 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58229 }
58230 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58231 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58232 }
58233 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58234 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58235 }
58236 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58237 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58238 }
58239 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58240 return (void *)((wxObject *) ((wxMenuItem *) x));
58241 }
58242 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58243 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58244 }
58245 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58246 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58247 }
58248 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58249 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58250 }
58251 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58252 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58253 }
58254 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58255 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58256 }
58257 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58258 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58259 }
58260 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58261 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58262 }
58263 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58264 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58265 }
58266 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58267 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58268 }
58269 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58270 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58271 }
58272 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58273 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58274 }
58275 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58276 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58277 }
58278 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58279 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58280 }
58281 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58282 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58283 }
58284 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58285 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58286 }
58287 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58288 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58289 }
58290 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58291 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58292 }
58293 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58294 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58295 }
58296 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58297 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58298 }
58299 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58300 return (void *)((wxObject *) ((wxImageHandler *) x));
58301 }
58302 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58303 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58304 }
58305 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58306 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58307 }
58308 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58309 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58310 }
58311 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58312 return (void *)((wxObject *) ((wxEvtHandler *) x));
58313 }
58314 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58315 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58316 }
58317 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58318 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58319 }
58320 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58321 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58322 }
58323 static void *_p_wxImageTo_p_wxObject(void *x) {
58324 return (void *)((wxObject *) ((wxImage *) x));
58325 }
58326 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58327 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58328 }
58329 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58330 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58331 }
58332 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58333 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58334 }
58335 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58336 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58337 }
58338 static void *_p_wxWindowTo_p_wxObject(void *x) {
58339 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58340 }
58341 static void *_p_wxMenuTo_p_wxObject(void *x) {
58342 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58343 }
58344 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58345 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58346 }
58347 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58348 return (void *)((wxObject *) ((wxFileSystem *) x));
58349 }
58350 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58351 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58352 }
58353 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58354 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58355 }
58356 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58357 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58358 }
58359 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58360 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58361 }
58362 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58363 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58364 }
58365 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58366 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58367 }
58368 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58369 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58370 }
58371 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58372 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58373 }
58374 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58375 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58376 }
58377 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58378 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58379 }
58380 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58381 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58382 }
58383 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58384 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58385 }
58386 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58387 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58388 }
58389 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58390 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58391 }
58392 static void *_p_wxControlTo_p_wxWindow(void *x) {
58393 return (void *)((wxWindow *) ((wxControl *) x));
58394 }
58395 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58396 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58397 }
58398 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58399 return (void *)((wxWindow *) ((wxMenuBar *) x));
58400 }
58401 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58402 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58403 }
58404 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58405 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58406 }
58407 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58408 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58409 }
58410 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58411 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58412 }
58413 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58414 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58415 }
58416 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58417 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58418 }
58419 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58420 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58421 }
58422 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58423 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58424 }
58425 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58426 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58427 }
58428 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58429 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58430 }
58431 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58432 return (void *)((wxValidator *) ((wxPyValidator *) x));
58433 }
58434 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58435 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58436 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};
58437 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58438 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58439 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58440 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58441 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58442 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58443 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58444 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58445 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58446 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58447 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58448 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58449 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58450 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58451 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58452 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58453 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58454 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58455 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58456 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58457 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58458 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58459 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58460 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58461 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58462 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58463 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58464 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58465 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58466 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58569
58570 static swig_type_info *swig_type_initial[] = {
58571 &_swigt__p_buffer,
58572 &_swigt__p_char,
58573 &_swigt__p_form_ops_t,
58574 &_swigt__p_int,
58575 &_swigt__p_long,
58576 &_swigt__p_unsigned_char,
58577 &_swigt__p_unsigned_int,
58578 &_swigt__p_unsigned_long,
58579 &_swigt__p_wxANIHandler,
58580 &_swigt__p_wxAcceleratorEntry,
58581 &_swigt__p_wxAcceleratorTable,
58582 &_swigt__p_wxActivateEvent,
58583 &_swigt__p_wxAppTraits,
58584 &_swigt__p_wxArrayString,
58585 &_swigt__p_wxBMPHandler,
58586 &_swigt__p_wxBitmap,
58587 &_swigt__p_wxBoxSizer,
58588 &_swigt__p_wxButton,
58589 &_swigt__p_wxCURHandler,
58590 &_swigt__p_wxCaret,
58591 &_swigt__p_wxChildFocusEvent,
58592 &_swigt__p_wxClipboardTextEvent,
58593 &_swigt__p_wxCloseEvent,
58594 &_swigt__p_wxColour,
58595 &_swigt__p_wxCommandEvent,
58596 &_swigt__p_wxContextMenuEvent,
58597 &_swigt__p_wxControl,
58598 &_swigt__p_wxControlWithItems,
58599 &_swigt__p_wxCursor,
58600 &_swigt__p_wxDC,
58601 &_swigt__p_wxDateEvent,
58602 &_swigt__p_wxDateTime,
58603 &_swigt__p_wxDisplayChangedEvent,
58604 &_swigt__p_wxDouble,
58605 &_swigt__p_wxDropFilesEvent,
58606 &_swigt__p_wxDuplexMode,
58607 &_swigt__p_wxEraseEvent,
58608 &_swigt__p_wxEvent,
58609 &_swigt__p_wxEventLoop,
58610 &_swigt__p_wxEventLoopActivator,
58611 &_swigt__p_wxEvtHandler,
58612 &_swigt__p_wxFSFile,
58613 &_swigt__p_wxFileSystem,
58614 &_swigt__p_wxFileSystemHandler,
58615 &_swigt__p_wxFlexGridSizer,
58616 &_swigt__p_wxFocusEvent,
58617 &_swigt__p_wxFont,
58618 &_swigt__p_wxFrame,
58619 &_swigt__p_wxGBPosition,
58620 &_swigt__p_wxGBSizerItem,
58621 &_swigt__p_wxGBSpan,
58622 &_swigt__p_wxGIFHandler,
58623 &_swigt__p_wxGridBagSizer,
58624 &_swigt__p_wxGridSizer,
58625 &_swigt__p_wxHelpEvent__Origin,
58626 &_swigt__p_wxICOHandler,
58627 &_swigt__p_wxIconizeEvent,
58628 &_swigt__p_wxIdleEvent,
58629 &_swigt__p_wxImage,
58630 &_swigt__p_wxImageHandler,
58631 &_swigt__p_wxImageHistogram,
58632 &_swigt__p_wxImage_HSVValue,
58633 &_swigt__p_wxImage_RGBValue,
58634 &_swigt__p_wxIndividualLayoutConstraint,
58635 &_swigt__p_wxInitDialogEvent,
58636 &_swigt__p_wxInputStream,
58637 &_swigt__p_wxInternetFSHandler,
58638 &_swigt__p_wxItemContainer,
58639 &_swigt__p_wxJPEGHandler,
58640 &_swigt__p_wxKeyEvent,
58641 &_swigt__p_wxLayoutConstraints,
58642 &_swigt__p_wxMaximizeEvent,
58643 &_swigt__p_wxMemoryFSHandler,
58644 &_swigt__p_wxMenu,
58645 &_swigt__p_wxMenuBar,
58646 &_swigt__p_wxMenuBarBase,
58647 &_swigt__p_wxMenuEvent,
58648 &_swigt__p_wxMenuItem,
58649 &_swigt__p_wxMouseCaptureChangedEvent,
58650 &_swigt__p_wxMouseCaptureLostEvent,
58651 &_swigt__p_wxMouseEvent,
58652 &_swigt__p_wxMoveEvent,
58653 &_swigt__p_wxNavigationKeyEvent,
58654 &_swigt__p_wxNcPaintEvent,
58655 &_swigt__p_wxNotifyEvent,
58656 &_swigt__p_wxObject,
58657 &_swigt__p_wxOutputStream,
58658 &_swigt__p_wxPCXHandler,
58659 &_swigt__p_wxPNGHandler,
58660 &_swigt__p_wxPNMHandler,
58661 &_swigt__p_wxPaintEvent,
58662 &_swigt__p_wxPaletteChangedEvent,
58663 &_swigt__p_wxPaperSize,
58664 &_swigt__p_wxPoint,
58665 &_swigt__p_wxPoint2D,
58666 &_swigt__p_wxPropagateOnce,
58667 &_swigt__p_wxPropagationDisabler,
58668 &_swigt__p_wxPyApp,
58669 &_swigt__p_wxPyCommandEvent,
58670 &_swigt__p_wxPyDropTarget,
58671 &_swigt__p_wxPyEvent,
58672 &_swigt__p_wxPyFileSystemHandler,
58673 &_swigt__p_wxPyImageHandler,
58674 &_swigt__p_wxPyInputStream,
58675 &_swigt__p_wxPySizer,
58676 &_swigt__p_wxPyValidator,
58677 &_swigt__p_wxQuantize,
58678 &_swigt__p_wxQueryNewPaletteEvent,
58679 &_swigt__p_wxRealPoint,
58680 &_swigt__p_wxRect,
58681 &_swigt__p_wxRect2D,
58682 &_swigt__p_wxRegion,
58683 &_swigt__p_wxScrollEvent,
58684 &_swigt__p_wxScrollWinEvent,
58685 &_swigt__p_wxSetCursorEvent,
58686 &_swigt__p_wxShowEvent,
58687 &_swigt__p_wxSize,
58688 &_swigt__p_wxSizeEvent,
58689 &_swigt__p_wxSizer,
58690 &_swigt__p_wxSizerItem,
58691 &_swigt__p_wxStaticBox,
58692 &_swigt__p_wxStaticBoxSizer,
58693 &_swigt__p_wxStdDialogButtonSizer,
58694 &_swigt__p_wxSysColourChangedEvent,
58695 &_swigt__p_wxTGAHandler,
58696 &_swigt__p_wxTIFFHandler,
58697 &_swigt__p_wxToolTip,
58698 &_swigt__p_wxUpdateUIEvent,
58699 &_swigt__p_wxValidator,
58700 &_swigt__p_wxVisualAttributes,
58701 &_swigt__p_wxWindow,
58702 &_swigt__p_wxWindowCreateEvent,
58703 &_swigt__p_wxWindowDestroyEvent,
58704 &_swigt__p_wxXPMHandler,
58705 &_swigt__p_wxZipFSHandler,
58706 };
58707
58708 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58709 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58710 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58711 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58712 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58713 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58714 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58715 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58716 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58717 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58718 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58719 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58720 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58721 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58722 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}};
58723 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58724 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}};
58725 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58726 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}};
58727 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58728 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58729 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58730 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58731 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58732 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}};
58733 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58734 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}};
58735 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58736 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58737 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58738 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58739 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58740 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58741 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58745 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}};
58746 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58747 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58748 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}};
58749 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58750 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58751 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}};
58752 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}};
58753 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58754 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58755 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58756 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58759 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58761 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}};
58762 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58763 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}};
58764 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58765 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58766 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58767 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}};
58768 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58775 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}};
58776 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58777 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58778 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58793 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}};
58794 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58826 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}};
58827 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}};
58828 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 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}};
58837 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58838 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}};
58839 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58843
58844 static swig_cast_info *swig_cast_initial[] = {
58845 _swigc__p_buffer,
58846 _swigc__p_char,
58847 _swigc__p_form_ops_t,
58848 _swigc__p_int,
58849 _swigc__p_long,
58850 _swigc__p_unsigned_char,
58851 _swigc__p_unsigned_int,
58852 _swigc__p_unsigned_long,
58853 _swigc__p_wxANIHandler,
58854 _swigc__p_wxAcceleratorEntry,
58855 _swigc__p_wxAcceleratorTable,
58856 _swigc__p_wxActivateEvent,
58857 _swigc__p_wxAppTraits,
58858 _swigc__p_wxArrayString,
58859 _swigc__p_wxBMPHandler,
58860 _swigc__p_wxBitmap,
58861 _swigc__p_wxBoxSizer,
58862 _swigc__p_wxButton,
58863 _swigc__p_wxCURHandler,
58864 _swigc__p_wxCaret,
58865 _swigc__p_wxChildFocusEvent,
58866 _swigc__p_wxClipboardTextEvent,
58867 _swigc__p_wxCloseEvent,
58868 _swigc__p_wxColour,
58869 _swigc__p_wxCommandEvent,
58870 _swigc__p_wxContextMenuEvent,
58871 _swigc__p_wxControl,
58872 _swigc__p_wxControlWithItems,
58873 _swigc__p_wxCursor,
58874 _swigc__p_wxDC,
58875 _swigc__p_wxDateEvent,
58876 _swigc__p_wxDateTime,
58877 _swigc__p_wxDisplayChangedEvent,
58878 _swigc__p_wxDouble,
58879 _swigc__p_wxDropFilesEvent,
58880 _swigc__p_wxDuplexMode,
58881 _swigc__p_wxEraseEvent,
58882 _swigc__p_wxEvent,
58883 _swigc__p_wxEventLoop,
58884 _swigc__p_wxEventLoopActivator,
58885 _swigc__p_wxEvtHandler,
58886 _swigc__p_wxFSFile,
58887 _swigc__p_wxFileSystem,
58888 _swigc__p_wxFileSystemHandler,
58889 _swigc__p_wxFlexGridSizer,
58890 _swigc__p_wxFocusEvent,
58891 _swigc__p_wxFont,
58892 _swigc__p_wxFrame,
58893 _swigc__p_wxGBPosition,
58894 _swigc__p_wxGBSizerItem,
58895 _swigc__p_wxGBSpan,
58896 _swigc__p_wxGIFHandler,
58897 _swigc__p_wxGridBagSizer,
58898 _swigc__p_wxGridSizer,
58899 _swigc__p_wxHelpEvent__Origin,
58900 _swigc__p_wxICOHandler,
58901 _swigc__p_wxIconizeEvent,
58902 _swigc__p_wxIdleEvent,
58903 _swigc__p_wxImage,
58904 _swigc__p_wxImageHandler,
58905 _swigc__p_wxImageHistogram,
58906 _swigc__p_wxImage_HSVValue,
58907 _swigc__p_wxImage_RGBValue,
58908 _swigc__p_wxIndividualLayoutConstraint,
58909 _swigc__p_wxInitDialogEvent,
58910 _swigc__p_wxInputStream,
58911 _swigc__p_wxInternetFSHandler,
58912 _swigc__p_wxItemContainer,
58913 _swigc__p_wxJPEGHandler,
58914 _swigc__p_wxKeyEvent,
58915 _swigc__p_wxLayoutConstraints,
58916 _swigc__p_wxMaximizeEvent,
58917 _swigc__p_wxMemoryFSHandler,
58918 _swigc__p_wxMenu,
58919 _swigc__p_wxMenuBar,
58920 _swigc__p_wxMenuBarBase,
58921 _swigc__p_wxMenuEvent,
58922 _swigc__p_wxMenuItem,
58923 _swigc__p_wxMouseCaptureChangedEvent,
58924 _swigc__p_wxMouseCaptureLostEvent,
58925 _swigc__p_wxMouseEvent,
58926 _swigc__p_wxMoveEvent,
58927 _swigc__p_wxNavigationKeyEvent,
58928 _swigc__p_wxNcPaintEvent,
58929 _swigc__p_wxNotifyEvent,
58930 _swigc__p_wxObject,
58931 _swigc__p_wxOutputStream,
58932 _swigc__p_wxPCXHandler,
58933 _swigc__p_wxPNGHandler,
58934 _swigc__p_wxPNMHandler,
58935 _swigc__p_wxPaintEvent,
58936 _swigc__p_wxPaletteChangedEvent,
58937 _swigc__p_wxPaperSize,
58938 _swigc__p_wxPoint,
58939 _swigc__p_wxPoint2D,
58940 _swigc__p_wxPropagateOnce,
58941 _swigc__p_wxPropagationDisabler,
58942 _swigc__p_wxPyApp,
58943 _swigc__p_wxPyCommandEvent,
58944 _swigc__p_wxPyDropTarget,
58945 _swigc__p_wxPyEvent,
58946 _swigc__p_wxPyFileSystemHandler,
58947 _swigc__p_wxPyImageHandler,
58948 _swigc__p_wxPyInputStream,
58949 _swigc__p_wxPySizer,
58950 _swigc__p_wxPyValidator,
58951 _swigc__p_wxQuantize,
58952 _swigc__p_wxQueryNewPaletteEvent,
58953 _swigc__p_wxRealPoint,
58954 _swigc__p_wxRect,
58955 _swigc__p_wxRect2D,
58956 _swigc__p_wxRegion,
58957 _swigc__p_wxScrollEvent,
58958 _swigc__p_wxScrollWinEvent,
58959 _swigc__p_wxSetCursorEvent,
58960 _swigc__p_wxShowEvent,
58961 _swigc__p_wxSize,
58962 _swigc__p_wxSizeEvent,
58963 _swigc__p_wxSizer,
58964 _swigc__p_wxSizerItem,
58965 _swigc__p_wxStaticBox,
58966 _swigc__p_wxStaticBoxSizer,
58967 _swigc__p_wxStdDialogButtonSizer,
58968 _swigc__p_wxSysColourChangedEvent,
58969 _swigc__p_wxTGAHandler,
58970 _swigc__p_wxTIFFHandler,
58971 _swigc__p_wxToolTip,
58972 _swigc__p_wxUpdateUIEvent,
58973 _swigc__p_wxValidator,
58974 _swigc__p_wxVisualAttributes,
58975 _swigc__p_wxWindow,
58976 _swigc__p_wxWindowCreateEvent,
58977 _swigc__p_wxWindowDestroyEvent,
58978 _swigc__p_wxXPMHandler,
58979 _swigc__p_wxZipFSHandler,
58980 };
58981
58982
58983 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
58984
58985 static swig_const_info swig_const_table[] = {
58986 {0, 0, 0, 0.0, 0, 0}};
58987
58988 #ifdef __cplusplus
58989 }
58990 #endif
58991 /* -----------------------------------------------------------------------------
58992 * Type initialization:
58993 * This problem is tough by the requirement that no dynamic
58994 * memory is used. Also, since swig_type_info structures store pointers to
58995 * swig_cast_info structures and swig_cast_info structures store pointers back
58996 * to swig_type_info structures, we need some lookup code at initialization.
58997 * The idea is that swig generates all the structures that are needed.
58998 * The runtime then collects these partially filled structures.
58999 * The SWIG_InitializeModule function takes these initial arrays out of
59000 * swig_module, and does all the lookup, filling in the swig_module.types
59001 * array with the correct data and linking the correct swig_cast_info
59002 * structures together.
59003 *
59004 * The generated swig_type_info structures are assigned staticly to an initial
59005 * array. We just loop though that array, and handle each type individually.
59006 * First we lookup if this type has been already loaded, and if so, use the
59007 * loaded structure instead of the generated one. Then we have to fill in the
59008 * cast linked list. The cast data is initially stored in something like a
59009 * two-dimensional array. Each row corresponds to a type (there are the same
59010 * number of rows as there are in the swig_type_initial array). Each entry in
59011 * a column is one of the swig_cast_info structures for that type.
59012 * The cast_initial array is actually an array of arrays, because each row has
59013 * a variable number of columns. So to actually build the cast linked list,
59014 * we find the array of casts associated with the type, and loop through it
59015 * adding the casts to the list. The one last trick we need to do is making
59016 * sure the type pointer in the swig_cast_info struct is correct.
59017 *
59018 * First off, we lookup the cast->type name to see if it is already loaded.
59019 * There are three cases to handle:
59020 * 1) If the cast->type has already been loaded AND the type we are adding
59021 * casting info to has not been loaded (it is in this module), THEN we
59022 * replace the cast->type pointer with the type pointer that has already
59023 * been loaded.
59024 * 2) If BOTH types (the one we are adding casting info to, and the
59025 * cast->type) are loaded, THEN the cast info has already been loaded by
59026 * the previous module so we just ignore it.
59027 * 3) Finally, if cast->type has not already been loaded, then we add that
59028 * swig_cast_info to the linked list (because the cast->type) pointer will
59029 * be correct.
59030 * ----------------------------------------------------------------------------- */
59031
59032 #ifdef __cplusplus
59033 extern "C" {
59034 #if 0
59035 } /* c-mode */
59036 #endif
59037 #endif
59038
59039 #if 0
59040 #define SWIGRUNTIME_DEBUG
59041 #endif
59042
59043 SWIGRUNTIME void
59044 SWIG_InitializeModule(void *clientdata) {
59045 size_t i;
59046 swig_module_info *module_head;
59047 static int init_run = 0;
59048
59049 clientdata = clientdata;
59050
59051 if (init_run) return;
59052 init_run = 1;
59053
59054 /* Initialize the swig_module */
59055 swig_module.type_initial = swig_type_initial;
59056 swig_module.cast_initial = swig_cast_initial;
59057
59058 /* Try and load any already created modules */
59059 module_head = SWIG_GetModule(clientdata);
59060 if (module_head) {
59061 swig_module.next = module_head->next;
59062 module_head->next = &swig_module;
59063 } else {
59064 /* This is the first module loaded */
59065 swig_module.next = &swig_module;
59066 SWIG_SetModule(clientdata, &swig_module);
59067 }
59068
59069 /* Now work on filling in swig_module.types */
59070 #ifdef SWIGRUNTIME_DEBUG
59071 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59072 #endif
59073 for (i = 0; i < swig_module.size; ++i) {
59074 swig_type_info *type = 0;
59075 swig_type_info *ret;
59076 swig_cast_info *cast;
59077
59078 #ifdef SWIGRUNTIME_DEBUG
59079 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59080 #endif
59081
59082 /* if there is another module already loaded */
59083 if (swig_module.next != &swig_module) {
59084 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59085 }
59086 if (type) {
59087 /* Overwrite clientdata field */
59088 #ifdef SWIGRUNTIME_DEBUG
59089 printf("SWIG_InitializeModule: found type %s\n", type->name);
59090 #endif
59091 if (swig_module.type_initial[i]->clientdata) {
59092 type->clientdata = swig_module.type_initial[i]->clientdata;
59093 #ifdef SWIGRUNTIME_DEBUG
59094 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59095 #endif
59096 }
59097 } else {
59098 type = swig_module.type_initial[i];
59099 }
59100
59101 /* Insert casting types */
59102 cast = swig_module.cast_initial[i];
59103 while (cast->type) {
59104 /* Don't need to add information already in the list */
59105 ret = 0;
59106 #ifdef SWIGRUNTIME_DEBUG
59107 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59108 #endif
59109 if (swig_module.next != &swig_module) {
59110 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59111 #ifdef SWIGRUNTIME_DEBUG
59112 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59113 #endif
59114 }
59115 if (ret) {
59116 if (type == swig_module.type_initial[i]) {
59117 #ifdef SWIGRUNTIME_DEBUG
59118 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59119 #endif
59120 cast->type = ret;
59121 ret = 0;
59122 } else {
59123 /* Check for casting already in the list */
59124 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59125 #ifdef SWIGRUNTIME_DEBUG
59126 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59127 #endif
59128 if (!ocast) ret = 0;
59129 }
59130 }
59131
59132 if (!ret) {
59133 #ifdef SWIGRUNTIME_DEBUG
59134 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59135 #endif
59136 if (type->cast) {
59137 type->cast->prev = cast;
59138 cast->next = type->cast;
59139 }
59140 type->cast = cast;
59141 }
59142 cast++;
59143 }
59144 /* Set entry in modules->types array equal to the type */
59145 swig_module.types[i] = type;
59146 }
59147 swig_module.types[i] = 0;
59148
59149 #ifdef SWIGRUNTIME_DEBUG
59150 printf("**** SWIG_InitializeModule: Cast List ******\n");
59151 for (i = 0; i < swig_module.size; ++i) {
59152 int j = 0;
59153 swig_cast_info *cast = swig_module.cast_initial[i];
59154 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59155 while (cast->type) {
59156 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59157 cast++;
59158 ++j;
59159 }
59160 printf("---- Total casts: %d\n",j);
59161 }
59162 printf("**** SWIG_InitializeModule: Cast List ******\n");
59163 #endif
59164 }
59165
59166 /* This function will propagate the clientdata field of type to
59167 * any new swig_type_info structures that have been added into the list
59168 * of equivalent types. It is like calling
59169 * SWIG_TypeClientData(type, clientdata) a second time.
59170 */
59171 SWIGRUNTIME void
59172 SWIG_PropagateClientData(void) {
59173 size_t i;
59174 swig_cast_info *equiv;
59175 static int init_run = 0;
59176
59177 if (init_run) return;
59178 init_run = 1;
59179
59180 for (i = 0; i < swig_module.size; i++) {
59181 if (swig_module.types[i]->clientdata) {
59182 equiv = swig_module.types[i]->cast;
59183 while (equiv) {
59184 if (!equiv->converter) {
59185 if (equiv->type && !equiv->type->clientdata)
59186 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59187 }
59188 equiv = equiv->next;
59189 }
59190 }
59191 }
59192 }
59193
59194 #ifdef __cplusplus
59195 #if 0
59196 {
59197 /* c-mode */
59198 #endif
59199 }
59200 #endif
59201
59202
59203
59204 #ifdef __cplusplus
59205 extern "C" {
59206 #endif
59207
59208 /* Python-specific SWIG API */
59209 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59210 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59211 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59212
59213 /* -----------------------------------------------------------------------------
59214 * global variable support code.
59215 * ----------------------------------------------------------------------------- */
59216
59217 typedef struct swig_globalvar {
59218 char *name; /* Name of global variable */
59219 PyObject *(*get_attr)(void); /* Return the current value */
59220 int (*set_attr)(PyObject *); /* Set the value */
59221 struct swig_globalvar *next;
59222 } swig_globalvar;
59223
59224 typedef struct swig_varlinkobject {
59225 PyObject_HEAD
59226 swig_globalvar *vars;
59227 } swig_varlinkobject;
59228
59229 SWIGINTERN PyObject *
59230 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59231 return PyString_FromString("<Swig global variables>");
59232 }
59233
59234 SWIGINTERN PyObject *
59235 swig_varlink_str(swig_varlinkobject *v) {
59236 PyObject *str = PyString_FromString("(");
59237 swig_globalvar *var;
59238 for (var = v->vars; var; var=var->next) {
59239 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59240 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59241 }
59242 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59243 return str;
59244 }
59245
59246 SWIGINTERN int
59247 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59248 PyObject *str = swig_varlink_str(v);
59249 fprintf(fp,"Swig global variables ");
59250 fprintf(fp,"%s\n", PyString_AsString(str));
59251 Py_DECREF(str);
59252 return 0;
59253 }
59254
59255 SWIGINTERN void
59256 swig_varlink_dealloc(swig_varlinkobject *v) {
59257 swig_globalvar *var = v->vars;
59258 while (var) {
59259 swig_globalvar *n = var->next;
59260 free(var->name);
59261 free(var);
59262 var = n;
59263 }
59264 }
59265
59266 SWIGINTERN PyObject *
59267 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59268 PyObject *res = NULL;
59269 swig_globalvar *var = v->vars;
59270 while (var) {
59271 if (strcmp(var->name,n) == 0) {
59272 res = (*var->get_attr)();
59273 break;
59274 }
59275 var = var->next;
59276 }
59277 if (res == NULL && !PyErr_Occurred()) {
59278 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59279 }
59280 return res;
59281 }
59282
59283 SWIGINTERN int
59284 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59285 int res = 1;
59286 swig_globalvar *var = v->vars;
59287 while (var) {
59288 if (strcmp(var->name,n) == 0) {
59289 res = (*var->set_attr)(p);
59290 break;
59291 }
59292 var = var->next;
59293 }
59294 if (res == 1 && !PyErr_Occurred()) {
59295 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59296 }
59297 return res;
59298 }
59299
59300 SWIGINTERN PyTypeObject*
59301 swig_varlink_type(void) {
59302 static char varlink__doc__[] = "Swig var link object";
59303 static PyTypeObject varlink_type;
59304 static int type_init = 0;
59305 if (!type_init) {
59306 const PyTypeObject tmp
59307 = {
59308 PyObject_HEAD_INIT(NULL)
59309 0, /* Number of items in variable part (ob_size) */
59310 (char *)"swigvarlink", /* Type name (tp_name) */
59311 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59312 0, /* Itemsize (tp_itemsize) */
59313 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59314 (printfunc) swig_varlink_print, /* Print (tp_print) */
59315 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59316 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59317 0, /* tp_compare */
59318 (reprfunc) swig_varlink_repr, /* tp_repr */
59319 0, /* tp_as_number */
59320 0, /* tp_as_sequence */
59321 0, /* tp_as_mapping */
59322 0, /* tp_hash */
59323 0, /* tp_call */
59324 (reprfunc)swig_varlink_str, /* tp_str */
59325 0, /* tp_getattro */
59326 0, /* tp_setattro */
59327 0, /* tp_as_buffer */
59328 0, /* tp_flags */
59329 varlink__doc__, /* tp_doc */
59330 0, /* tp_traverse */
59331 0, /* tp_clear */
59332 0, /* tp_richcompare */
59333 0, /* tp_weaklistoffset */
59334 #if PY_VERSION_HEX >= 0x02020000
59335 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59336 #endif
59337 #if PY_VERSION_HEX >= 0x02030000
59338 0, /* tp_del */
59339 #endif
59340 #ifdef COUNT_ALLOCS
59341 0,0,0,0 /* tp_alloc -> tp_next */
59342 #endif
59343 };
59344 varlink_type = tmp;
59345 varlink_type.ob_type = &PyType_Type;
59346 type_init = 1;
59347 }
59348 return &varlink_type;
59349 }
59350
59351 /* Create a variable linking object for use later */
59352 SWIGINTERN PyObject *
59353 SWIG_Python_newvarlink(void) {
59354 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59355 if (result) {
59356 result->vars = 0;
59357 }
59358 return ((PyObject*) result);
59359 }
59360
59361 SWIGINTERN void
59362 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59363 swig_varlinkobject *v = (swig_varlinkobject *) p;
59364 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59365 if (gv) {
59366 size_t size = strlen(name)+1;
59367 gv->name = (char *)malloc(size);
59368 if (gv->name) {
59369 strncpy(gv->name,name,size);
59370 gv->get_attr = get_attr;
59371 gv->set_attr = set_attr;
59372 gv->next = v->vars;
59373 }
59374 }
59375 v->vars = gv;
59376 }
59377
59378 SWIGINTERN PyObject *
59379 SWIG_globals() {
59380 static PyObject *_SWIG_globals = 0;
59381 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59382 return _SWIG_globals;
59383 }
59384
59385 /* -----------------------------------------------------------------------------
59386 * constants/methods manipulation
59387 * ----------------------------------------------------------------------------- */
59388
59389 /* Install Constants */
59390 SWIGINTERN void
59391 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59392 PyObject *obj = 0;
59393 size_t i;
59394 for (i = 0; constants[i].type; ++i) {
59395 switch(constants[i].type) {
59396 case SWIG_PY_POINTER:
59397 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59398 break;
59399 case SWIG_PY_BINARY:
59400 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59401 break;
59402 default:
59403 obj = 0;
59404 break;
59405 }
59406 if (obj) {
59407 PyDict_SetItemString(d, constants[i].name, obj);
59408 Py_DECREF(obj);
59409 }
59410 }
59411 }
59412
59413 /* -----------------------------------------------------------------------------*/
59414 /* Fix SwigMethods to carry the callback ptrs when needed */
59415 /* -----------------------------------------------------------------------------*/
59416
59417 SWIGINTERN void
59418 SWIG_Python_FixMethods(PyMethodDef *methods,
59419 swig_const_info *const_table,
59420 swig_type_info **types,
59421 swig_type_info **types_initial) {
59422 size_t i;
59423 for (i = 0; methods[i].ml_name; ++i) {
59424 const char *c = methods[i].ml_doc;
59425 if (c && (c = strstr(c, "swig_ptr: "))) {
59426 int j;
59427 swig_const_info *ci = 0;
59428 const char *name = c + 10;
59429 for (j = 0; const_table[j].type; ++j) {
59430 if (strncmp(const_table[j].name, name,
59431 strlen(const_table[j].name)) == 0) {
59432 ci = &(const_table[j]);
59433 break;
59434 }
59435 }
59436 if (ci) {
59437 size_t shift = (ci->ptype) - types;
59438 swig_type_info *ty = types_initial[shift];
59439 size_t ldoc = (c - methods[i].ml_doc);
59440 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59441 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59442 if (ndoc) {
59443 char *buff = ndoc;
59444 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59445 if (ptr) {
59446 strncpy(buff, methods[i].ml_doc, ldoc);
59447 buff += ldoc;
59448 strncpy(buff, "swig_ptr: ", 10);
59449 buff += 10;
59450 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59451 methods[i].ml_doc = ndoc;
59452 }
59453 }
59454 }
59455 }
59456 }
59457 }
59458
59459 #ifdef __cplusplus
59460 }
59461 #endif
59462
59463 /* -----------------------------------------------------------------------------*
59464 * Partial Init method
59465 * -----------------------------------------------------------------------------*/
59466
59467 #ifdef __cplusplus
59468 extern "C"
59469 #endif
59470 SWIGEXPORT void SWIG_init(void) {
59471 PyObject *m, *d;
59472
59473 /* Fix SwigMethods to carry the callback ptrs when needed */
59474 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59475
59476 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59477 d = PyModule_GetDict(m);
59478
59479 SWIG_InitializeModule(0);
59480 SWIG_InstallConstants(d,swig_const_table);
59481
59482
59483
59484 #ifndef wxPyUSE_EXPORT
59485 // Make our API structure a CObject so other modules can import it
59486 // from this module.
59487 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59488 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59489 Py_XDECREF(cobj);
59490 #endif
59491
59492 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59493 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59494 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59495 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59496 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59497 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59498 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59499 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59500 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59501 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59502 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59503 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59504 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59505 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59506 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59507 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59508 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59509 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59510 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59511 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59512 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59513 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59514 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59515 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59516 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59517 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59518 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59519 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59520 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59521 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59522 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59523 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59524 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59525 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59526 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59527 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59528 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59529 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59530 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59531 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59532 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59533 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59534 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59535 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59536 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59537 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59538 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59539 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59540 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59541 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59542 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59543 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59544 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59545 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59546 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59547 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59548 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59549 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59550 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59551 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59552 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59553 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59554 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59555 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59556 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59557 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59558 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59559 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59560 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59561 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59562 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59563 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59564 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59565 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59566 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59567 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59568 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59569 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59570 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59571 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59572 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59573 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59574 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59575 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59576 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59577 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59578 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59579 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59580 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59581 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59582 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59583 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59584 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59585 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59586 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59587 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59588 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59589 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59590 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59591 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59592 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59593 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59594 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59595 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59596 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59597 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59598 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59599 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59600 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59601 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59602 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59603 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59604 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59605 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59606 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59607 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59608 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59609 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59610 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59611 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59612 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59613 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59614 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59615 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59616 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59617 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59618 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59619 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59620 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59621 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59622 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59623 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59624 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59625 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59626 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59627 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59628 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59629 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59630 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59631 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59632 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59633 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59634 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59635 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59636 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59637 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59638 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59639 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59640 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59641 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59642 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59643 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59644 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59645 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59646 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59647 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59648 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59649 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59650 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59651 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59652 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59653 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59654 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59655 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59656 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59657 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59658 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59659 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59660 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59661 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59662 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59663 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59664 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59665 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59666 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59667 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59668 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59669 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59670 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59671 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59672 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59673 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59674 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59675 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59676 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59677 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59678 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59679 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59680 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59681 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59682 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59683 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59684 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59685 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59686 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59687 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59688 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59689 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59690 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59691 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59692 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59693 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59694 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59695 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59696 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59697 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59698 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59699 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59700 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59701 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59702 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59703 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59704 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59705 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59706 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59707 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59708 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59709 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59710 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59711 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59712 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59713 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59714 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59715 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59716 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59717 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59718 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59719 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59720 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59721 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59722 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59723 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59724 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59725 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59726 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59727 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59728 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59729 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59730 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59731 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59732 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59733 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59734 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59735 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59736 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59737 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59738 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59739 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59740 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59741 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59742 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59743 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59744 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59745 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59746 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59747 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59748 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59749 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59750 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59751 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59752 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59753 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59754 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59755 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59756 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59757 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59758 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59759 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59760 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59761 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59762 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59763 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59764 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59765 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59766 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59767 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59768 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59769 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59770 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59771 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59772 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59773 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59774 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59775 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59776 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59777 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59778 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59779 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59780 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59781 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59782 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59783 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59784 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59785 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59786 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59787 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59788 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59789 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59790 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59791 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59792 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59793 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59794 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59795 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59796 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59797 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59798 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59799 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59800 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59801 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59802 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59803 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59804 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59805 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59806 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59807 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59808 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59809 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59810 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59811 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59812 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59813 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59814 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59815 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59816 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59817 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59818 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59819 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59820 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59821 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59822 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59823 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59824 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59825 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59826 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59827 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59828 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59829 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59830 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59831 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59832 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59833 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59834 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59835 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59836 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59837 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59838 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59839 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59840 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59841 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59842 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59843 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59844 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59845 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59846 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59847 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59848 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59849 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59850 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59851 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59852 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59853 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59854 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59855 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59856 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59857 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59858 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59859 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59860 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59861 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59862 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59863 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59864 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59865 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59866 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59867 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59868 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59869 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59870 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59871 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59872 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59873 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59874 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59875 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59876 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59877 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59878 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59879 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59880 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59881 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59882 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59883 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59884 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59885 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59886 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59887 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59888 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59889 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59890 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59891 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59892 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59893 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59894 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59895 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59896 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59897 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59898 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59913 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59914 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59915 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59916 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59917 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59918 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59919 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59920 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59921 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59922 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59923 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59924 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59925 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59926 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59927 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59928 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59929 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59930 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59931 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59932 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59933 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59934 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59935 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59936 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59937 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59938 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59939 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59940 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59941 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59942 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59943 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59944 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59945 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59946 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59947 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59948 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59949 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59950 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59951 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59952 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59953 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59954 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59955 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59956 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59957 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59958 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59959 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59960 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59961 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59962 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59963 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59964 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59965 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59966 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59967 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59968 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59969 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59970 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
59971 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
59972 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
59973 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
59974 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
59975 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
59976 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
59977 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
59978 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
59979 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
59980 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
59981 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
59982 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
59983 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
59984 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
59985 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
59986 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
59987 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
59988 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
59989 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
59990 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
59991 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
59992 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
59993 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
59994 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
59995 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
59996 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
59997 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
59998 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
59999 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60000 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60001 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60002 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60003 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60004 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60005 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60006 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60007 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60008 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60009 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60010 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60011 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60012 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60013 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60014 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60015 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60016 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60017 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60018 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60019 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60020 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60021 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60022 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60023 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60024 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60025 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60026 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60027 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60028 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60029 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60030 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60031 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60032 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60033 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60034 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60035 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60036 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60037 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60038 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60039 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60040 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60041 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60042 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60043 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60044 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60045 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60046 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60047 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60048 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60049 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60050 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60051 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60052 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60053 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60054 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60055 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60056 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60057 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60058 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60059 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60060 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60061 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60062 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60063 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60064 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60065 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60066 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60067 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60068 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60069 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60070 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60071 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60072 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60073 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60074 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60075 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60076 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60077 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60078 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60079 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60080 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60081 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60082 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60083 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60084 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60085 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60086 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60087 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60088 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60089 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60090 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60091 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60092 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60093 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60094 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60095 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60096 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60097 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60098 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60099 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60100 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60101 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60102 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60103 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60104 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60105 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60106 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60107 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60108 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60109 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60110 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60116 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60117 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60118 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60119 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60120 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60121 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60122 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60123 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60124 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60125 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60126 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60127 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60128 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60129 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60130 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60131 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60132 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60133 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60134 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60135 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60136 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60137 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60138 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60139 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60140 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60141 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60142 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60143 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60144 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60145 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60146 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60147 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60148 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60149 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60150 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60151 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60152 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60153 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60154 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60155 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60156 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60157
60158 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60159
60160
60161 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60162
60163 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60164 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60165 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60166 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60167 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60168 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60169 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60170 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60171 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60172 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60173 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60174 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60175 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60176 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60177 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60178 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60179 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60180 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60181 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60182 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60184 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60185 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60186 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60187 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60188 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60189 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60190 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60191 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60192 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60193 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60194 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60195 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60196 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60197 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60198 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60199 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60200 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60201 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60202 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60203 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60204 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60205 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60206 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60207 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60208 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60209 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60210 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60211 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60212 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60213 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60214 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60215 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60216 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60217 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60218 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60219 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60220 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60221 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60222 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60223 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60224 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60225 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60226 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60227 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60228 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60229 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60230 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60231 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60232 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60233 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60234 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60235 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60236 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60237 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60238 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60239 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60240 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60241 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60242 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60243 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60244 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60245 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60246 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60247 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60248 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60249 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60250 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60251 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60252 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60253 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60254 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60255 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60256 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60257 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60258 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60259 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60260 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60261 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60262 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60263 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60264 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60265 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60266 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60267 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60268 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60269 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60270 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60271 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60272 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60273 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60274 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60275 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60276 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60277 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60278 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60279 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60280 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60281 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60282 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60283 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60284 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60285 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60286 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60287 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60288 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60289 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60290 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60291 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60292 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60293 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60294 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60295 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60296 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60297 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60298 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60299 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60300 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60301 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60302 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60303 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60304 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60305 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60306 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60307 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60308 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60309 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60310 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60311 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60312 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60313 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60314 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60315 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60316 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60320 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60321 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60322 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60323 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60324 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60325 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60326 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60327 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60328 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60329 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60330 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60331 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60332 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60333 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60334 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60335 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60336 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60337 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60338 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60339 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60340 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60341 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60342 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60343 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60344 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60345 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60346 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60347 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60348 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60349 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60350 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60351 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60352 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60353 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60354 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60355 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60356 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60357 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60358 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60359 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60360 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60361 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60362 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60363 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60364 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60365 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60366 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60367 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60368 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60369 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60370 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60371 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60372 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60373 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60374 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60375 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60376 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60377
60378 // Initialize threading, some globals and such
60379 __wxPyPreStart(d);
60380
60381
60382 // Although these are defined in __version__ they need to be here too so
60383 // that an assert can be done to ensure that the wxPython and the wxWindows
60384 // versions match.
60385 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60386 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60387 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60388
60389 }
60390
wxWidgets (Impactor)