]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2957 wxSize temp, *obj = &temp;
2958 if ( other == Py_None ) return false;
2959 if ( ! wxSize_helper(other, &obj) ) {
2960 PyErr_Clear();
2961 return false;
2962 }
2963 return self->operator==(*obj);
2964 }
2965 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return true;
2968 if ( ! wxSize_helper(other, &obj)) {
2969 PyErr_Clear();
2970 return true;
2971 }
2972 return self->operator!=(*obj);
2973 }
2974 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 PyObject* tup = PyTuple_New(2);
2977 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2978 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2979 wxPyEndBlockThreads(blocked);
2980 return tup;
2981 }
2982
2983 SWIGINTERN int
2984 SWIG_AsVal_double (PyObject *obj, double* val)
2985 {
2986 if (PyNumber_Check(obj)) {
2987 if (val) *val = PyFloat_AsDouble(obj);
2988 return SWIG_OK;
2989 }
2990 return SWIG_TypeError;
2991 }
2992
2993
2994 #define SWIG_From_double PyFloat_FromDouble
2995
2996 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2997 wxRealPoint temp, *obj = &temp;
2998 if ( other == Py_None ) return false;
2999 if ( ! wxRealPoint_helper(other, &obj) ) {
3000 PyErr_Clear();
3001 return false;
3002 }
3003 return self->operator==(*obj);
3004 }
3005 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3006 wxRealPoint temp, *obj = &temp;
3007 if ( other == Py_None ) return true;
3008 if ( ! wxRealPoint_helper(other, &obj)) {
3009 PyErr_Clear();
3010 return true;
3011 }
3012 return self->operator!=(*obj);
3013 }
3014 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3015 self->x = x;
3016 self->y = y;
3017 }
3018 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3023 wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3027 wxPoint temp, *obj = &temp;
3028 if ( other == Py_None ) return false;
3029 if ( ! wxPoint_helper(other, &obj) ) {
3030 PyErr_Clear();
3031 return false;
3032 }
3033 return self->operator==(*obj);
3034 }
3035 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3036 wxPoint temp, *obj = &temp;
3037 if ( other == Py_None ) return true;
3038 if ( ! wxPoint_helper(other, &obj)) {
3039 PyErr_Clear();
3040 return true;
3041 }
3042 return self->operator!=(*obj);
3043 }
3044 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3045 self->x = x;
3046 self->y = y;
3047 }
3048 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 PyObject* tup = PyTuple_New(2);
3051 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3052 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3053 wxPyEndBlockThreads(blocked);
3054 return tup;
3055 }
3056 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3057 wxRect temp, *obj = &temp;
3058 if ( other == Py_None ) return false;
3059 if ( ! wxRect_helper(other, &obj) ) {
3060 PyErr_Clear();
3061 return false;
3062 }
3063 return self->operator==(*obj);
3064 }
3065 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3066 wxRect temp, *obj = &temp;
3067 if ( other == Py_None ) return true;
3068 if ( ! wxRect_helper(other, &obj)) {
3069 PyErr_Clear();
3070 return true;
3071 }
3072 return self->operator!=(*obj);
3073 }
3074 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3075 self->x = x;
3076 self->y = y;
3077 self->width = width;
3078 self->height = height;
3079 }
3080 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3082 PyObject* tup = PyTuple_New(4);
3083 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3084 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3085 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3086 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3087 wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090
3091 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3092 wxRegion reg1(*r1);
3093 wxRegion reg2(*r2);
3094 wxRect dest(0,0,0,0);
3095 PyObject* obj;
3096
3097 reg1.Intersect(reg2);
3098 dest = reg1.GetBox();
3099
3100 if (dest != wxRect(0,0,0,0)) {
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3102 wxRect* newRect = new wxRect(dest);
3103 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3104 wxPyEndBlockThreads(blocked);
3105 return obj;
3106 }
3107 Py_INCREF(Py_None);
3108 return Py_None;
3109 }
3110
3111 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3112 wxPoint2D temp, *obj = &temp;
3113 if ( other == Py_None ) return false;
3114 if ( ! wxPoint2D_helper(other, &obj) ) {
3115 PyErr_Clear();
3116 return false;
3117 }
3118 return self->operator==(*obj);
3119 }
3120 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3121 wxPoint2D temp, *obj = &temp;
3122 if ( other == Py_None ) return true;
3123 if ( ! wxPoint2D_helper(other, &obj)) {
3124 PyErr_Clear();
3125 return true;
3126 }
3127 return self->operator!=(*obj);
3128 }
3129 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3130 self->m_x = x;
3131 self->m_y = y;
3132 }
3133 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3137 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141
3142 #include "wx/wxPython/pyistream.h"
3143
3144 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3145 wxInputStream* wxis = wxPyCBInputStream::create(p);
3146 if (wxis)
3147 return new wxPyInputStream(wxis);
3148 else
3149 return NULL;
3150 }
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_From_char (char c)
3184 {
3185 return SWIG_FromCharPtrAndSize(&c,1);
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject*
3190 SWIG_From_unsigned_SS_long (unsigned long value)
3191 {
3192 return (value > LONG_MAX) ?
3193 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3194 }
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_size_t (size_t value)
3199 {
3200 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3201 }
3202
3203
3204 SWIGINTERN int
3205 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3206 {
3207 if (PyString_Check(obj)) {
3208 char *cstr; int len;
3209 PyString_AsStringAndSize(obj, &cstr, &len);
3210 if (cptr) {
3211 if (alloc) {
3212 /*
3213 In python the user should not be able to modify the inner
3214 string representation. To warranty that, if you define
3215 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3216 buffer is always returned.
3217
3218 The default behavior is just to return the pointer value,
3219 so, be careful.
3220 */
3221 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3222 if (*alloc != SWIG_OLDOBJ)
3223 #else
3224 if (*alloc == SWIG_NEWOBJ)
3225 #endif
3226 {
3227 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3228 *alloc = SWIG_NEWOBJ;
3229 }
3230 else {
3231 *cptr = cstr;
3232 *alloc = SWIG_OLDOBJ;
3233 }
3234 } else {
3235 *cptr = PyString_AsString(obj);
3236 }
3237 }
3238 if (psize) *psize = len + 1;
3239 return SWIG_OK;
3240 } else {
3241 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3242 if (pchar_descriptor) {
3243 void* vptr = 0;
3244 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3245 if (cptr) *cptr = (char *) vptr;
3246 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3247 if (alloc) *alloc = SWIG_OLDOBJ;
3248 return SWIG_OK;
3249 }
3250 }
3251 }
3252 return SWIG_TypeError;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3258 {
3259 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3260 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3261 if (SWIG_IsOK(res)) {
3262 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3263 if (csize <= size) {
3264 if (val) {
3265 if (csize) memcpy(val, cptr, csize*sizeof(char));
3266 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3267 }
3268 if (alloc == SWIG_NEWOBJ) {
3269 delete[] cptr;
3270 res = SWIG_DelNewMask(res);
3271 }
3272 return res;
3273 }
3274 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3275 }
3276 return SWIG_TypeError;
3277 }
3278
3279
3280 SWIGINTERN int
3281 SWIG_AsVal_char (PyObject * obj, char *val)
3282 {
3283 int res = SWIG_AsCharArray(obj, val, 1);
3284 if (!SWIG_IsOK(res)) {
3285 long v;
3286 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3287 if (SWIG_IsOK(res)) {
3288 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3289 if (val) *val = static_cast< char >(v);
3290 } else {
3291 res = SWIG_OverflowError;
3292 }
3293 }
3294 }
3295 return res;
3296 }
3297
3298 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3299 // We use only strings for the streams, not unicode
3300 PyObject* str = PyObject_Str(obj);
3301 if (! str) {
3302 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3303 return;
3304 }
3305 self->Write(PyString_AS_STRING(str),
3306 PyString_GET_SIZE(str));
3307 Py_DECREF(str);
3308 }
3309
3310 #include "wx/wxPython/pyistream.h"
3311
3312
3313 class wxPyFileSystemHandler : public wxFileSystemHandler
3314 {
3315 public:
3316 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3317
3318 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3319 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3320 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3321 DEC_PYCALLBACK_STRING__pure(FindNext);
3322
3323 wxString GetProtocol(const wxString& location) {
3324 return wxFileSystemHandler::GetProtocol(location);
3325 }
3326
3327 wxString GetLeftLocation(const wxString& location) {
3328 return wxFileSystemHandler::GetLeftLocation(location);
3329 }
3330
3331 wxString GetAnchor(const wxString& location) {
3332 return wxFileSystemHandler::GetAnchor(location);
3333 }
3334
3335 wxString GetRightLocation(const wxString& location) {
3336 return wxFileSystemHandler::GetRightLocation(location);
3337 }
3338
3339 wxString GetMimeTypeFromExt(const wxString& location) {
3340 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3341 }
3342
3343 PYPRIVATE;
3344 };
3345
3346
3347 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3348 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3349 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3350 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3351
3352
3353 SWIGINTERN int
3354 SWIG_AsVal_bool (PyObject *obj, bool *val)
3355 {
3356 if (obj == Py_True) {
3357 if (val) *val = true;
3358 return SWIG_OK;
3359 } else if (obj == Py_False) {
3360 if (val) *val = false;
3361 return SWIG_OK;
3362 } else {
3363 long v = 0;
3364 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3365 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3366 return res;
3367 }
3368 }
3369
3370 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3371 wxFileName fname = wxFileSystem::URLToFileName(url);
3372 return fname.GetFullPath();
3373 }
3374
3375 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3376 wxImage& image,
3377 long type) {
3378 wxMemoryFSHandler::AddFile(filename, image, type);
3379 }
3380
3381 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3382 const wxBitmap& bitmap,
3383 long type) {
3384 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3385 }
3386
3387 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3388 PyObject* data) {
3389 if (! PyString_Check(data)) {
3390 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3391 "Expected string object"));
3392 return;
3393 }
3394
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 void* ptr = (void*)PyString_AsString(data);
3397 size_t size = PyString_Size(data);
3398 wxPyEndBlockThreads(blocked);
3399
3400 wxMemoryFSHandler::AddFile(filename, ptr, size);
3401 }
3402
3403
3404 #include "wx/wxPython/pyistream.h"
3405
3406
3407 SWIGINTERN int
3408 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3409 {
3410 long v = 0;
3411 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3412 return SWIG_TypeError;
3413 }
3414 else if (val)
3415 *val = (unsigned long)v;
3416 return SWIG_OK;
3417 }
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3422 {
3423 unsigned long v;
3424 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3425 if (SWIG_IsOK(res)) {
3426 if ((v > UCHAR_MAX)) {
3427 return SWIG_OverflowError;
3428 } else {
3429 if (val) *val = static_cast< unsigned char >(v);
3430 }
3431 }
3432 return res;
3433 }
3434
3435
3436 SWIGINTERNINLINE PyObject *
3437 SWIG_From_unsigned_SS_char (unsigned char value)
3438 {
3439 return SWIG_From_unsigned_SS_long (value);
3440 }
3441
3442 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3443 wxImageHistogramEntry e = (*self)[key];
3444 return e.value;
3445 }
3446 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3447 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3448 wxImageHistogramEntry e = (*self)[key];
3449 return e.value;
3450 }
3451 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3452 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3453 colour.Green(),
3454 colour.Blue());
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458
3459 typedef unsigned char* buffer;
3460
3461
3462 // Pull the nested class out to the top level for SWIG's sake
3463 #define wxImage_RGBValue wxImage::RGBValue
3464 #define wxImage_HSVValue wxImage::HSVValue
3465
3466 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3467 if (width > 0 && height > 0)
3468 return new wxImage(width, height, clear);
3469 else
3470 return new wxImage;
3471 }
3472 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3473 return new wxImage(bitmap.ConvertToImage());
3474 }
3475 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3476 if (DATASIZE != width*height*3) {
3477 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3478 return NULL;
3479 }
3480
3481 // Copy the source data so the wxImage can clean it up later
3482 buffer copy = (buffer)malloc(DATASIZE);
3483 if (copy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return NULL;
3486 }
3487 memcpy(copy, data, DATASIZE);
3488 return new wxImage(width, height, copy, false);
3489 }
3490 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3491 if (DATASIZE != width*height*3) {
3492 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3493 return NULL;
3494 }
3495 if (ALPHASIZE != width*height) {
3496 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3497 return NULL;
3498 }
3499
3500 // Copy the source data so the wxImage can clean it up later
3501 buffer dcopy = (buffer)malloc(DATASIZE);
3502 if (dcopy == NULL) {
3503 wxPyBLOCK_THREADS(PyErr_NoMemory());
3504 return NULL;
3505 }
3506 memcpy(dcopy, data, DATASIZE);
3507
3508 buffer acopy = (buffer)malloc(ALPHASIZE);
3509 if (acopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(acopy, alpha, ALPHASIZE);
3514
3515 return new wxImage(width, height, dcopy, acopy, false);
3516 }
3517 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3518 wxSize size(self->GetWidth(), self->GetHeight());
3519 return size;
3520 }
3521 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3522 buffer data = self->GetData();
3523 int len = self->GetWidth() * self->GetHeight() * 3;
3524 PyObject* rv;
3525 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3526 return rv;
3527 }
3528 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3529 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3530 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3531 return;
3532 }
3533 buffer copy = (buffer)malloc(DATASIZE);
3534 if (copy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return;
3537 }
3538 memcpy(copy, data, DATASIZE);
3539 self->SetData(copy, false);
3540 // wxImage takes ownership of copy...
3541 }
3542 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3543 buffer data = self->GetData();
3544 int len = self->GetWidth() * self->GetHeight() * 3;
3545 PyObject* rv;
3546 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3547 return rv;
3548 }
3549 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3550 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3551 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3552 return;
3553 }
3554 self->SetData(data, true);
3555 }
3556 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3557 buffer data = self->GetAlpha();
3558 if (! data) {
3559 RETURN_NONE();
3560 } else {
3561 int len = self->GetWidth() * self->GetHeight();
3562 PyObject* rv;
3563 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3564 return rv;
3565 }
3566 }
3567 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3568 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3569 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3570 return;
3571 }
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578 self->SetAlpha(acopy, false);
3579 // wxImage takes ownership of acopy...
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 int len = self->GetWidth() * self->GetHeight();
3584 PyObject* rv;
3585 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3586 return rv;
3587 }
3588 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3589 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3590 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3591 return;
3592 }
3593 self->SetAlpha(alpha, true);
3594 }
3595 SWIGINTERN PyObject *wxImage_GetHandlers(){
3596 wxList& list = wxImage::GetHandlers();
3597 return wxPy_ConvertList(&list);
3598 }
3599 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3600 wxBitmap bitmap(*self, depth);
3601 return bitmap;
3602 }
3603 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3604 wxImage mono = self->ConvertToMono( red, green, blue );
3605 wxBitmap bitmap( mono, 1 );
3606 return bitmap;
3607 }
3608 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3609 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3612 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3616 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3617 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3618 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3619 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3620 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3621 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3622 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3623
3624 #include <wx/quantize.h>
3625
3626 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3627 return wxQuantize::Quantize(src, dest,
3628 //NULL, // palette
3629 desiredNoColours,
3630 NULL, // eightBitData
3631 flags);
3632 }
3633 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3634 if (PyCallable_Check(func)) {
3635 self->Connect(id, lastId, eventType,
3636 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3637 new wxPyCallback(func));
3638 }
3639 else if (func == Py_None) {
3640 self->Disconnect(id, lastId, eventType,
3641 (wxObjectEventFunction)
3642 &wxPyCallback::EventThunker);
3643 }
3644 else {
3645 wxPyBLOCK_THREADS(
3646 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3647 }
3648 }
3649 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3650 return self->Disconnect(id, lastId, eventType,
3651 (wxObjectEventFunction)
3652 &wxPyCallback::EventThunker);
3653 }
3654 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3655 if (_self && _self != Py_None) {
3656 self->SetClientObject(new wxPyOORClientData(_self, incref));
3657 }
3658 else {
3659 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3660 if (data) {
3661 self->SetClientObject(NULL); // This will delete it too
3662 }
3663 }
3664 }
3665
3666 #if ! wxUSE_HOTKEY
3667 #define wxEVT_HOTKEY -9999
3668 #endif
3669
3670 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3671 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3672 if (data) {
3673 Py_INCREF(data->m_obj);
3674 return data->m_obj;
3675 } else {
3676 Py_INCREF(Py_None);
3677 return Py_None;
3678 }
3679 }
3680 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3681 wxPyClientData* data = new wxPyClientData(clientData);
3682 self->SetClientObject(data);
3683 }
3684 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3685 #if wxUSE_UNICODE
3686 return self->GetUnicodeKey();
3687 #else
3688 return 0;
3689 #endif
3690 }
3691
3692 SWIGINTERNINLINE PyObject *
3693 SWIG_From_unsigned_SS_int (unsigned int value)
3694 {
3695 return SWIG_From_unsigned_SS_long (value);
3696 }
3697
3698
3699 SWIGINTERN int
3700 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3701 {
3702 unsigned long v;
3703 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3704 if (SWIG_IsOK(res)) {
3705 if ((v > UINT_MAX)) {
3706 return SWIG_OverflowError;
3707 } else {
3708 if (val) *val = static_cast< unsigned int >(v);
3709 }
3710 }
3711 return res;
3712 }
3713
3714 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3715 self->m_size = size;
3716 }
3717 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3718 int count = self->GetNumberOfFiles();
3719 wxString* files = self->GetFiles();
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722
3723 if (!list) {
3724 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3725 wxPyEndBlockThreads(blocked);
3726 return NULL;
3727 }
3728
3729 for (int i=0; i<count; i++) {
3730 PyList_SetItem(list, i, wx2PyString(files[i]));
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 return list;
3734 }
3735
3736
3737 SWIGINTERN wxPyApp *new_wxPyApp(){
3738 wxPythonApp = new wxPyApp();
3739 return wxPythonApp;
3740 }
3741
3742 void wxApp_CleanUp() {
3743 __wxPyCleanup();
3744 }
3745
3746
3747 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3748
3749
3750
3751
3752
3753 SWIGINTERNINLINE PyObject *
3754 SWIG_FromCharPtr(const char *cptr)
3755 {
3756 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3757 }
3758
3759
3760 #if 0 // #ifdef __WXMAC__
3761
3762 // A dummy class that raises an exception if used...
3763 class wxEventLoop
3764 {
3765 public:
3766 wxEventLoop() { wxPyRaiseNotImplemented(); }
3767 int Run() { return 0; }
3768 void Exit(int rc = 0) {}
3769 bool Pending() const { return false; }
3770 bool Dispatch() { return false; }
3771 bool IsRunning() const { return false; }
3772 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3773 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3774 };
3775
3776 #else
3777
3778 #include <wx/evtloop.h>
3779
3780 #endif
3781
3782
3783
3784 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3785 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3786 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3787 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3788 wxWindowList& list = self->GetChildren();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3792 #if wxUSE_HOTKEY
3793 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3794 #else
3795 return false;
3796 #endif
3797 }
3798 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3799
3800
3801
3802 return false;
3803
3804 }
3805 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3806 return wxPyGetWinHandle(self);
3807 }
3808 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3809 self->AssociateHandle((WXWidget)handle);
3810 }
3811
3812 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3813 return wxWindow::FindWindowById(id, parent);
3814 }
3815
3816 wxWindow* wxFindWindowByName( const wxString& name,
3817 const wxWindow *parent = NULL ) {
3818 return wxWindow::FindWindowByName(name, parent);
3819 }
3820
3821 wxWindow* wxFindWindowByLabel( const wxString& label,
3822 const wxWindow *parent = NULL ) {
3823 return wxWindow::FindWindowByLabel(label, parent);
3824 }
3825
3826
3827 #ifdef __WXMSW__
3828 #include <wx/msw/private.h> // to get wxGetWindowId
3829 #endif
3830
3831
3832 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3833 #ifdef __WXMSW__
3834 WXHWND hWnd = (WXHWND)_hWnd;
3835 long id = wxGetWindowId(hWnd);
3836 wxWindow* win = new wxWindow;
3837 if (parent)
3838 parent->AddChild(win);
3839 win->SetEventHandler(win);
3840 win->SetHWND(hWnd);
3841 win->SetId(id);
3842 win->SubclassWin(hWnd);
3843 win->AdoptAttributesFromHWND();
3844 win->SetupColours();
3845 return win;
3846 #else
3847 wxPyRaiseNotImplemented();
3848 return NULL;
3849 #endif
3850 }
3851
3852
3853 PyObject* GetTopLevelWindows() {
3854 return wxPy_ConvertList(&wxTopLevelWindows);
3855 }
3856
3857
3858 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3859 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3860 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3861
3862 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3863
3864
3865 SWIGINTERNINLINE int
3866 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3867 {
3868 unsigned long v;
3869 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3870 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3871 return res;
3872 }
3873
3874 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3875 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3876 wxMenuItemList& list = self->GetMenuItems();
3877 return wxPy_ConvertList(&list);
3878 }
3879 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3880 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3881 static const wxString wxPyControlNameStr(wxControlNameStr);
3882 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3883 if (clientData) {
3884 wxPyClientData* data = new wxPyClientData(clientData);
3885 return self->Append(item, data);
3886 } else
3887 return self->Append(item);
3888 }
3889 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3890 if (clientData) {
3891 wxPyClientData* data = new wxPyClientData(clientData);
3892 return self->Insert(item, pos, data);
3893 } else
3894 return self->Insert(item, pos);
3895 }
3896 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3897 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3898 if (data) {
3899 Py_INCREF(data->m_obj);
3900 return data->m_obj;
3901 } else {
3902 Py_INCREF(Py_None);
3903 return Py_None;
3904 }
3905 }
3906 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3907 wxPyClientData* data = new wxPyClientData(clientData);
3908 self->SetClientObject(n, data);
3909 }
3910
3911
3912 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3913 wxPyUserData* data = NULL;
3914 if ( userData ) {
3915 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3916 data = new wxPyUserData(userData);
3917 wxPyEndBlockThreads(blocked);
3918 }
3919 return new wxSizerItem(window, proportion, flag, border, data);
3920 }
3921 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3922 wxPyUserData* data = NULL;
3923 if ( userData ) {
3924 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3925 data = new wxPyUserData(userData);
3926 wxPyEndBlockThreads(blocked);
3927 }
3928 return new wxSizerItem(width, height, proportion, flag, border, data);
3929 }
3930 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3931 wxPyUserData* data = NULL;
3932 if ( userData ) {
3933 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3934 data = new wxPyUserData(userData);
3935 wxPyEndBlockThreads(blocked);
3936 }
3937 return new wxSizerItem(sizer, proportion, flag, border, data);
3938 }
3939
3940 #include <float.h>
3941
3942
3943 SWIGINTERN int
3944 SWIG_AsVal_float (PyObject * obj, float *val)
3945 {
3946 double v;
3947 int res = SWIG_AsVal_double (obj, &v);
3948 if (SWIG_IsOK(res)) {
3949 if ((v < -FLT_MAX || v > FLT_MAX)) {
3950 return SWIG_OverflowError;
3951 } else {
3952 if (val) *val = static_cast< float >(v);
3953 }
3954 }
3955 return res;
3956 }
3957
3958
3959 SWIGINTERNINLINE PyObject *
3960 SWIG_From_float (float value)
3961 {
3962 return SWIG_From_double (value);
3963 }
3964
3965 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3966 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3967 if (data) {
3968 Py_INCREF(data->m_obj);
3969 return data->m_obj;
3970 } else {
3971 Py_INCREF(Py_None);
3972 return Py_None;
3973 }
3974 }
3975 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3976 wxPyUserData* data = NULL;
3977 if ( userData ) {
3978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3979 data = new wxPyUserData(userData);
3980 wxPyEndBlockThreads(blocked);
3981 }
3982 self->SetUserData(data);
3983 }
3984
3985 // Figure out the type of the sizer item
3986
3987 struct wxPySizerItemInfo {
3988 wxPySizerItemInfo()
3989 : window(NULL), sizer(NULL), gotSize(false),
3990 size(wxDefaultSize), gotPos(false), pos(-1)
3991 {}
3992
3993 wxWindow* window;
3994 wxSizer* sizer;
3995 bool gotSize;
3996 wxSize size;
3997 bool gotPos;
3998 int pos;
3999 };
4000
4001 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4002
4003 wxPySizerItemInfo info;
4004 wxSize size;
4005 wxSize* sizePtr = &size;
4006
4007 // Find out what the type of the item is
4008 // try wxWindow
4009 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4010 PyErr_Clear();
4011 info.window = NULL;
4012
4013 // try wxSizer
4014 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4015 PyErr_Clear();
4016 info.sizer = NULL;
4017
4018 // try wxSize or (w,h)
4019 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4020 info.size = *sizePtr;
4021 info.gotSize = true;
4022 }
4023
4024 // or a single int
4025 if (checkIdx && PyInt_Check(item)) {
4026 info.pos = PyInt_AsLong(item);
4027 info.gotPos = true;
4028 }
4029 }
4030 }
4031
4032 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4033 // no expected type, figure out what kind of error message to generate
4034 if ( !checkSize && !checkIdx )
4035 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4036 else if ( checkSize && !checkIdx )
4037 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4038 else if ( !checkSize && checkIdx)
4039 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4040 else
4041 // can this one happen?
4042 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4043 }
4044
4045 return info;
4046 }
4047
4048 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4049 if (!self->GetClientObject())
4050 self->SetClientObject(new wxPyOORClientData(_self));
4051 }
4052 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4053
4054 wxPyUserData* data = NULL;
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4057 if ( userData && (info.window || info.sizer || info.gotSize) )
4058 data = new wxPyUserData(userData);
4059 if ( info.sizer )
4060 PyObject_SetAttrString(item,"thisown",Py_False);
4061 wxPyEndBlockThreads(blocked);
4062
4063 // Now call the real Add method if a valid item type was found
4064 if ( info.window )
4065 return self->Add(info.window, proportion, flag, border, data);
4066 else if ( info.sizer )
4067 return self->Add(info.sizer, proportion, flag, border, data);
4068 else if (info.gotSize)
4069 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4070 proportion, flag, border, data);
4071 else
4072 return NULL;
4073 }
4074 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4075
4076 wxPyUserData* data = NULL;
4077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4079 if ( userData && (info.window || info.sizer || info.gotSize) )
4080 data = new wxPyUserData(userData);
4081 if ( info.sizer )
4082 PyObject_SetAttrString(item,"thisown",Py_False);
4083 wxPyEndBlockThreads(blocked);
4084
4085 // Now call the real Insert method if a valid item type was found
4086 if ( info.window )
4087 return self->Insert(before, info.window, proportion, flag, border, data);
4088 else if ( info.sizer )
4089 return self->Insert(before, info.sizer, proportion, flag, border, data);
4090 else if (info.gotSize)
4091 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4092 proportion, flag, border, data);
4093 else
4094 return NULL;
4095 }
4096 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4097
4098 wxPyUserData* data = NULL;
4099 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4100 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4101 if ( userData && (info.window || info.sizer || info.gotSize) )
4102 data = new wxPyUserData(userData);
4103 if ( info.sizer )
4104 PyObject_SetAttrString(item,"thisown",Py_False);
4105 wxPyEndBlockThreads(blocked);
4106
4107 // Now call the real Prepend method if a valid item type was found
4108 if ( info.window )
4109 return self->Prepend(info.window, proportion, flag, border, data);
4110 else if ( info.sizer )
4111 return self->Prepend(info.sizer, proportion, flag, border, data);
4112 else if (info.gotSize)
4113 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4114 proportion, flag, border, data);
4115 else
4116 return NULL;
4117 }
4118 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4119 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4120 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4121 wxPyEndBlockThreads(blocked);
4122 if ( info.window )
4123 return self->Remove(info.window);
4124 else if ( info.sizer )
4125 return self->Remove(info.sizer);
4126 else if ( info.gotPos )
4127 return self->Remove(info.pos);
4128 else
4129 return false;
4130 }
4131 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4134 wxPyEndBlockThreads(blocked);
4135 if ( info.window )
4136 return self->Detach(info.window);
4137 else if ( info.sizer )
4138 return self->Detach(info.sizer);
4139 else if ( info.gotPos )
4140 return self->Detach(info.pos);
4141 else
4142 return false;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4145 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4146 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4147 wxPyEndBlockThreads(blocked);
4148 if ( info.window )
4149 return self->GetItem(info.window);
4150 else if ( info.sizer )
4151 return self->GetItem(info.sizer);
4152 else if ( info.gotPos )
4153 return self->GetItem(info.pos);
4154 else
4155 return NULL;
4156 }
4157 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4160 wxPyEndBlockThreads(blocked);
4161 if ( info.window )
4162 self->SetItemMinSize(info.window, size);
4163 else if ( info.sizer )
4164 self->SetItemMinSize(info.sizer, size);
4165 else if ( info.gotPos )
4166 self->SetItemMinSize(info.pos, size);
4167 }
4168 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4169 wxSizerItemList& list = self->GetChildren();
4170 return wxPy_ConvertList(&list);
4171 }
4172 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 return self->Show(info.window, show, recursive);
4178 else if ( info.sizer )
4179 return self->Show(info.sizer, show, recursive);
4180 else if ( info.gotPos )
4181 return self->Show(info.pos, show);
4182 else
4183 return false;
4184 }
4185 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 return self->IsShown(info.window);
4191 else if ( info.sizer )
4192 return self->IsShown(info.sizer);
4193 else if ( info.gotPos )
4194 return self->IsShown(info.pos);
4195 else
4196 return false;
4197 }
4198
4199 // See pyclasses.h
4200 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4201 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4202 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4203
4204
4205
4206
4207 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4208 {
4209 if (source == Py_None) {
4210 **obj = wxGBPosition(-1,-1);
4211 return true;
4212 }
4213 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4214 }
4215
4216 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4217 {
4218 if (source == Py_None) {
4219 **obj = wxGBSpan(-1,-1);
4220 return true;
4221 }
4222 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4223 }
4224
4225
4226 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4227 wxGBPosition temp, *obj = &temp;
4228 if ( other == Py_None ) return false;
4229 if ( ! wxGBPosition_helper(other, &obj) ) {
4230 PyErr_Clear();
4231 return false;
4232 }
4233 return self->operator==(*obj);
4234 }
4235 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4236 wxGBPosition temp, *obj = &temp;
4237 if ( other == Py_None ) return true;
4238 if ( ! wxGBPosition_helper(other, &obj)) {
4239 PyErr_Clear();
4240 return true;
4241 }
4242 return self->operator!=(*obj);
4243 }
4244 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4245 self->SetRow(row);
4246 self->SetCol(col);
4247 }
4248 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4249 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4250 PyObject* tup = PyTuple_New(2);
4251 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4252 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4253 wxPyEndBlockThreads(blocked);
4254 return tup;
4255 }
4256 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4257 wxGBSpan temp, *obj = &temp;
4258 if ( other == Py_None ) return false;
4259 if ( ! wxGBSpan_helper(other, &obj) ) {
4260 PyErr_Clear();
4261 return false;
4262 }
4263 return self->operator==(*obj);
4264 }
4265 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4266 wxGBSpan temp, *obj = &temp;
4267 if ( other == Py_None ) return true;
4268 if ( ! wxGBSpan_helper(other, &obj)) {
4269 PyErr_Clear();
4270 return true;
4271 }
4272 return self->operator!=(*obj);
4273 }
4274 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4275 self->SetRowspan(rowspan);
4276 self->SetColspan(colspan);
4277 }
4278 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 PyObject* tup = PyTuple_New(2);
4281 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4282 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4283 wxPyEndBlockThreads(blocked);
4284 return tup;
4285 }
4286 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4287 wxPyUserData* data = NULL;
4288 if ( userData ) {
4289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4290 data = new wxPyUserData(userData);
4291 wxPyEndBlockThreads(blocked);
4292 }
4293 return new wxGBSizerItem(window, pos, span, flag, border, data);
4294 }
4295 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4296 wxPyUserData* data = NULL;
4297 if ( userData ) {
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 data = new wxPyUserData(userData);
4300 wxPyEndBlockThreads(blocked);
4301 }
4302 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4303 }
4304 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4305 wxPyUserData* data = NULL;
4306 if ( userData ) {
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 data = new wxPyUserData(userData);
4309 wxPyEndBlockThreads(blocked);
4310 }
4311 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4312 }
4313 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4314 int row, col;
4315 self->GetEndPos(row, col);
4316 return wxGBPosition(row, col);
4317 }
4318 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4319
4320 wxPyUserData* data = NULL;
4321 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4322 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4323 if ( userData && (info.window || info.sizer || info.gotSize) )
4324 data = new wxPyUserData(userData);
4325 if ( info.sizer )
4326 PyObject_SetAttrString(item,"thisown",Py_False);
4327 wxPyEndBlockThreads(blocked);
4328
4329 // Now call the real Add method if a valid item type was found
4330 if ( info.window )
4331 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4332 else if ( info.sizer )
4333 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4334 else if (info.gotSize)
4335 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4336 pos, span, flag, border, data);
4337 return NULL;
4338 }
4339
4340
4341 #ifdef __cplusplus
4342 extern "C" {
4343 #endif
4344 SWIGINTERN int EmptyString_set(PyObject *) {
4345 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4346 return 1;
4347 }
4348
4349
4350 SWIGINTERN PyObject *EmptyString_get(void) {
4351 PyObject *pyobj = 0;
4352
4353 {
4354 #if wxUSE_UNICODE
4355 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4356 #else
4357 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4358 #endif
4359 }
4360 return pyobj;
4361 }
4362
4363
4364 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4365 PyObject *resultobj = 0;
4366 wxObject *arg1 = (wxObject *) 0 ;
4367 wxString result;
4368 void *argp1 = 0 ;
4369 int res1 = 0 ;
4370 PyObject *swig_obj[1] ;
4371
4372 if (!args) SWIG_fail;
4373 swig_obj[0] = args;
4374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4375 if (!SWIG_IsOK(res1)) {
4376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4377 }
4378 arg1 = reinterpret_cast< wxObject * >(argp1);
4379 {
4380 PyThreadState* __tstate = wxPyBeginAllowThreads();
4381 result = wxObject_GetClassName(arg1);
4382 wxPyEndAllowThreads(__tstate);
4383 if (PyErr_Occurred()) SWIG_fail;
4384 }
4385 {
4386 #if wxUSE_UNICODE
4387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4388 #else
4389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4390 #endif
4391 }
4392 return resultobj;
4393 fail:
4394 return NULL;
4395 }
4396
4397
4398 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4399 PyObject *resultobj = 0;
4400 wxObject *arg1 = (wxObject *) 0 ;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 wxObject_Destroy(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 resultobj = SWIG_Py_Void();
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4426 PyObject *obj;
4427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4428 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4429 return SWIG_Py_Void();
4430 }
4431
4432 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4433 PyObject *resultobj = 0;
4434 wxSize *arg1 = (wxSize *) 0 ;
4435 int arg2 ;
4436 void *argp1 = 0 ;
4437 int res1 = 0 ;
4438 int val2 ;
4439 int ecode2 = 0 ;
4440 PyObject *swig_obj[2] ;
4441
4442 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4444 if (!SWIG_IsOK(res1)) {
4445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4446 }
4447 arg1 = reinterpret_cast< wxSize * >(argp1);
4448 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4449 if (!SWIG_IsOK(ecode2)) {
4450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4451 }
4452 arg2 = static_cast< int >(val2);
4453 if (arg1) (arg1)->x = arg2;
4454
4455 resultobj = SWIG_Py_Void();
4456 return resultobj;
4457 fail:
4458 return NULL;
4459 }
4460
4461
4462 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 PyObject *resultobj = 0;
4464 wxSize *arg1 = (wxSize *) 0 ;
4465 int result;
4466 void *argp1 = 0 ;
4467 int res1 = 0 ;
4468 PyObject *swig_obj[1] ;
4469
4470 if (!args) SWIG_fail;
4471 swig_obj[0] = args;
4472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4473 if (!SWIG_IsOK(res1)) {
4474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4475 }
4476 arg1 = reinterpret_cast< wxSize * >(argp1);
4477 result = (int) ((arg1)->x);
4478 resultobj = SWIG_From_int(static_cast< int >(result));
4479 return resultobj;
4480 fail:
4481 return NULL;
4482 }
4483
4484
4485 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4486 PyObject *resultobj = 0;
4487 wxSize *arg1 = (wxSize *) 0 ;
4488 int arg2 ;
4489 void *argp1 = 0 ;
4490 int res1 = 0 ;
4491 int val2 ;
4492 int ecode2 = 0 ;
4493 PyObject *swig_obj[2] ;
4494
4495 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4497 if (!SWIG_IsOK(res1)) {
4498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4499 }
4500 arg1 = reinterpret_cast< wxSize * >(argp1);
4501 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4502 if (!SWIG_IsOK(ecode2)) {
4503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4504 }
4505 arg2 = static_cast< int >(val2);
4506 if (arg1) (arg1)->y = arg2;
4507
4508 resultobj = SWIG_Py_Void();
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516 PyObject *resultobj = 0;
4517 wxSize *arg1 = (wxSize *) 0 ;
4518 int result;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 PyObject *swig_obj[1] ;
4522
4523 if (!args) SWIG_fail;
4524 swig_obj[0] = args;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4528 }
4529 arg1 = reinterpret_cast< wxSize * >(argp1);
4530 result = (int) ((arg1)->y);
4531 resultobj = SWIG_From_int(static_cast< int >(result));
4532 return resultobj;
4533 fail:
4534 return NULL;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj = 0;
4540 int arg1 = (int) 0 ;
4541 int arg2 = (int) 0 ;
4542 wxSize *result = 0 ;
4543 int val1 ;
4544 int ecode1 = 0 ;
4545 int val2 ;
4546 int ecode2 = 0 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char * kwnames[] = {
4550 (char *) "w",(char *) "h", NULL
4551 };
4552
4553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4554 if (obj0) {
4555 ecode1 = SWIG_AsVal_int(obj0, &val1);
4556 if (!SWIG_IsOK(ecode1)) {
4557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4558 }
4559 arg1 = static_cast< int >(val1);
4560 }
4561 if (obj1) {
4562 ecode2 = SWIG_AsVal_int(obj1, &val2);
4563 if (!SWIG_IsOK(ecode2)) {
4564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4565 }
4566 arg2 = static_cast< int >(val2);
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = (wxSize *)new wxSize(arg1,arg2);
4571 wxPyEndAllowThreads(__tstate);
4572 if (PyErr_Occurred()) SWIG_fail;
4573 }
4574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4575 return resultobj;
4576 fail:
4577 return NULL;
4578 }
4579
4580
4581 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 PyObject *resultobj = 0;
4583 wxSize *arg1 = (wxSize *) 0 ;
4584 void *argp1 = 0 ;
4585 int res1 = 0 ;
4586 PyObject *swig_obj[1] ;
4587
4588 if (!args) SWIG_fail;
4589 swig_obj[0] = args;
4590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4591 if (!SWIG_IsOK(res1)) {
4592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4593 }
4594 arg1 = reinterpret_cast< wxSize * >(argp1);
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 delete arg1;
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 resultobj = SWIG_Py_Void();
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj = 0;
4611 wxSize *arg1 = (wxSize *) 0 ;
4612 PyObject *arg2 = (PyObject *) 0 ;
4613 bool result;
4614 void *argp1 = 0 ;
4615 int res1 = 0 ;
4616 PyObject * obj0 = 0 ;
4617 PyObject * obj1 = 0 ;
4618 char * kwnames[] = {
4619 (char *) "self",(char *) "other", NULL
4620 };
4621
4622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 arg2 = obj1;
4629 {
4630 result = (bool)wxSize___eq__(arg1,arg2);
4631 if (PyErr_Occurred()) SWIG_fail;
4632 }
4633 {
4634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4635 }
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___ne__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 wxSize *arg2 = 0 ;
4679 wxSize result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 wxSize temp2 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "self",(char *) "sz", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4691 if (!SWIG_IsOK(res1)) {
4692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4693 }
4694 arg1 = reinterpret_cast< wxSize * >(argp1);
4695 {
4696 arg2 = &temp2;
4697 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4698 }
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = (arg1)->operator +((wxSize const &)*arg2);
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4713 PyObject *resultobj = 0;
4714 wxSize *arg1 = (wxSize *) 0 ;
4715 wxSize *arg2 = 0 ;
4716 wxSize result;
4717 void *argp1 = 0 ;
4718 int res1 = 0 ;
4719 wxSize temp2 ;
4720 PyObject * obj0 = 0 ;
4721 PyObject * obj1 = 0 ;
4722 char * kwnames[] = {
4723 (char *) "self",(char *) "sz", NULL
4724 };
4725
4726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4728 if (!SWIG_IsOK(res1)) {
4729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4730 }
4731 arg1 = reinterpret_cast< wxSize * >(argp1);
4732 {
4733 arg2 = &temp2;
4734 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4735 }
4736 {
4737 PyThreadState* __tstate = wxPyBeginAllowThreads();
4738 result = (arg1)->operator -((wxSize const &)*arg2);
4739 wxPyEndAllowThreads(__tstate);
4740 if (PyErr_Occurred()) SWIG_fail;
4741 }
4742 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 wxSize *arg1 = (wxSize *) 0 ;
4752 wxSize *arg2 = 0 ;
4753 void *argp1 = 0 ;
4754 int res1 = 0 ;
4755 wxSize temp2 ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 char * kwnames[] = {
4759 (char *) "self",(char *) "sz", NULL
4760 };
4761
4762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4764 if (!SWIG_IsOK(res1)) {
4765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4766 }
4767 arg1 = reinterpret_cast< wxSize * >(argp1);
4768 {
4769 arg2 = &temp2;
4770 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 (arg1)->IncTo((wxSize const &)*arg2);
4775 wxPyEndAllowThreads(__tstate);
4776 if (PyErr_Occurred()) SWIG_fail;
4777 }
4778 resultobj = SWIG_Py_Void();
4779 return resultobj;
4780 fail:
4781 return NULL;
4782 }
4783
4784
4785 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4786 PyObject *resultobj = 0;
4787 wxSize *arg1 = (wxSize *) 0 ;
4788 wxSize *arg2 = 0 ;
4789 void *argp1 = 0 ;
4790 int res1 = 0 ;
4791 wxSize temp2 ;
4792 PyObject * obj0 = 0 ;
4793 PyObject * obj1 = 0 ;
4794 char * kwnames[] = {
4795 (char *) "self",(char *) "sz", NULL
4796 };
4797
4798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4800 if (!SWIG_IsOK(res1)) {
4801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4802 }
4803 arg1 = reinterpret_cast< wxSize * >(argp1);
4804 {
4805 arg2 = &temp2;
4806 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4807 }
4808 {
4809 PyThreadState* __tstate = wxPyBeginAllowThreads();
4810 (arg1)->DecTo((wxSize const &)*arg2);
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 resultobj = SWIG_Py_Void();
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4822 PyObject *resultobj = 0;
4823 wxSize *arg1 = (wxSize *) 0 ;
4824 int arg2 ;
4825 int arg3 ;
4826 void *argp1 = 0 ;
4827 int res1 = 0 ;
4828 int val2 ;
4829 int ecode2 = 0 ;
4830 int val3 ;
4831 int ecode3 = 0 ;
4832 PyObject * obj0 = 0 ;
4833 PyObject * obj1 = 0 ;
4834 PyObject * obj2 = 0 ;
4835 char * kwnames[] = {
4836 (char *) "self",(char *) "w",(char *) "h", NULL
4837 };
4838
4839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4841 if (!SWIG_IsOK(res1)) {
4842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4843 }
4844 arg1 = reinterpret_cast< wxSize * >(argp1);
4845 ecode2 = SWIG_AsVal_int(obj1, &val2);
4846 if (!SWIG_IsOK(ecode2)) {
4847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4848 }
4849 arg2 = static_cast< int >(val2);
4850 ecode3 = SWIG_AsVal_int(obj2, &val3);
4851 if (!SWIG_IsOK(ecode3)) {
4852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4853 }
4854 arg3 = static_cast< int >(val3);
4855 {
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 (arg1)->Set(arg2,arg3);
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 resultobj = SWIG_Py_Void();
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj = 0;
4870 wxSize *arg1 = (wxSize *) 0 ;
4871 int arg2 ;
4872 void *argp1 = 0 ;
4873 int res1 = 0 ;
4874 int val2 ;
4875 int ecode2 = 0 ;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 char * kwnames[] = {
4879 (char *) "self",(char *) "w", NULL
4880 };
4881
4882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4884 if (!SWIG_IsOK(res1)) {
4885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4886 }
4887 arg1 = reinterpret_cast< wxSize * >(argp1);
4888 ecode2 = SWIG_AsVal_int(obj1, &val2);
4889 if (!SWIG_IsOK(ecode2)) {
4890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4891 }
4892 arg2 = static_cast< int >(val2);
4893 {
4894 PyThreadState* __tstate = wxPyBeginAllowThreads();
4895 (arg1)->SetWidth(arg2);
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 resultobj = SWIG_Py_Void();
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4907 PyObject *resultobj = 0;
4908 wxSize *arg1 = (wxSize *) 0 ;
4909 int arg2 ;
4910 void *argp1 = 0 ;
4911 int res1 = 0 ;
4912 int val2 ;
4913 int ecode2 = 0 ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 char * kwnames[] = {
4917 (char *) "self",(char *) "h", NULL
4918 };
4919
4920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4922 if (!SWIG_IsOK(res1)) {
4923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4924 }
4925 arg1 = reinterpret_cast< wxSize * >(argp1);
4926 ecode2 = SWIG_AsVal_int(obj1, &val2);
4927 if (!SWIG_IsOK(ecode2)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4929 }
4930 arg2 = static_cast< int >(val2);
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 (arg1)->SetHeight(arg2);
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 resultobj = SWIG_Py_Void();
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4945 PyObject *resultobj = 0;
4946 wxSize *arg1 = (wxSize *) 0 ;
4947 int result;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 PyObject *swig_obj[1] ;
4951
4952 if (!args) SWIG_fail;
4953 swig_obj[0] = args;
4954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4955 if (!SWIG_IsOK(res1)) {
4956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4957 }
4958 arg1 = reinterpret_cast< wxSize * >(argp1);
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (int)((wxSize const *)arg1)->GetWidth();
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 resultobj = SWIG_From_int(static_cast< int >(result));
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4973 PyObject *resultobj = 0;
4974 wxSize *arg1 = (wxSize *) 0 ;
4975 int result;
4976 void *argp1 = 0 ;
4977 int res1 = 0 ;
4978 PyObject *swig_obj[1] ;
4979
4980 if (!args) SWIG_fail;
4981 swig_obj[0] = args;
4982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 {
4988 PyThreadState* __tstate = wxPyBeginAllowThreads();
4989 result = (int)((wxSize const *)arg1)->GetHeight();
4990 wxPyEndAllowThreads(__tstate);
4991 if (PyErr_Occurred()) SWIG_fail;
4992 }
4993 resultobj = SWIG_From_int(static_cast< int >(result));
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002 wxSize *arg1 = (wxSize *) 0 ;
5003 bool result;
5004 void *argp1 = 0 ;
5005 int res1 = 0 ;
5006 PyObject *swig_obj[1] ;
5007
5008 if (!args) SWIG_fail;
5009 swig_obj[0] = args;
5010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 {
5016 PyThreadState* __tstate = wxPyBeginAllowThreads();
5017 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 {
5022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5023 }
5024 return resultobj;
5025 fail:
5026 return NULL;
5027 }
5028
5029
5030 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5031 PyObject *resultobj = 0;
5032 wxSize *arg1 = (wxSize *) 0 ;
5033 wxSize *arg2 = 0 ;
5034 void *argp1 = 0 ;
5035 int res1 = 0 ;
5036 wxSize temp2 ;
5037 PyObject * obj0 = 0 ;
5038 PyObject * obj1 = 0 ;
5039 char * kwnames[] = {
5040 (char *) "self",(char *) "size", NULL
5041 };
5042
5043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5045 if (!SWIG_IsOK(res1)) {
5046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5047 }
5048 arg1 = reinterpret_cast< wxSize * >(argp1);
5049 {
5050 arg2 = &temp2;
5051 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5052 }
5053 {
5054 PyThreadState* __tstate = wxPyBeginAllowThreads();
5055 (arg1)->SetDefaults((wxSize const &)*arg2);
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 PyObject *resultobj = 0;
5068 wxSize *arg1 = (wxSize *) 0 ;
5069 PyObject *result = 0 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 PyObject *swig_obj[1] ;
5073
5074 if (!args) SWIG_fail;
5075 swig_obj[0] = args;
5076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5077 if (!SWIG_IsOK(res1)) {
5078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5079 }
5080 arg1 = reinterpret_cast< wxSize * >(argp1);
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 result = (PyObject *)wxSize_Get(arg1);
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = result;
5088 return resultobj;
5089 fail:
5090 return NULL;
5091 }
5092
5093
5094 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5095 PyObject *obj;
5096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5097 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5098 return SWIG_Py_Void();
5099 }
5100
5101 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102 return SWIG_Python_InitShadowInstance(args);
5103 }
5104
5105 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5106 PyObject *resultobj = 0;
5107 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5108 double arg2 ;
5109 void *argp1 = 0 ;
5110 int res1 = 0 ;
5111 double val2 ;
5112 int ecode2 = 0 ;
5113 PyObject *swig_obj[2] ;
5114
5115 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5117 if (!SWIG_IsOK(res1)) {
5118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5119 }
5120 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5121 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5122 if (!SWIG_IsOK(ecode2)) {
5123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5124 }
5125 arg2 = static_cast< double >(val2);
5126 if (arg1) (arg1)->x = arg2;
5127
5128 resultobj = SWIG_Py_Void();
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5136 PyObject *resultobj = 0;
5137 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5138 double result;
5139 void *argp1 = 0 ;
5140 int res1 = 0 ;
5141 PyObject *swig_obj[1] ;
5142
5143 if (!args) SWIG_fail;
5144 swig_obj[0] = args;
5145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5146 if (!SWIG_IsOK(res1)) {
5147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5148 }
5149 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5150 result = (double) ((arg1)->x);
5151 resultobj = SWIG_From_double(static_cast< double >(result));
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5159 PyObject *resultobj = 0;
5160 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5161 double arg2 ;
5162 void *argp1 = 0 ;
5163 int res1 = 0 ;
5164 double val2 ;
5165 int ecode2 = 0 ;
5166 PyObject *swig_obj[2] ;
5167
5168 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5170 if (!SWIG_IsOK(res1)) {
5171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5172 }
5173 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5174 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5175 if (!SWIG_IsOK(ecode2)) {
5176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5177 }
5178 arg2 = static_cast< double >(val2);
5179 if (arg1) (arg1)->y = arg2;
5180
5181 resultobj = SWIG_Py_Void();
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5189 PyObject *resultobj = 0;
5190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5191 double result;
5192 void *argp1 = 0 ;
5193 int res1 = 0 ;
5194 PyObject *swig_obj[1] ;
5195
5196 if (!args) SWIG_fail;
5197 swig_obj[0] = args;
5198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5199 if (!SWIG_IsOK(res1)) {
5200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5201 }
5202 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5203 result = (double) ((arg1)->y);
5204 resultobj = SWIG_From_double(static_cast< double >(result));
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj = 0;
5213 double arg1 = (double) 0.0 ;
5214 double arg2 = (double) 0.0 ;
5215 wxRealPoint *result = 0 ;
5216 double val1 ;
5217 int ecode1 = 0 ;
5218 double val2 ;
5219 int ecode2 = 0 ;
5220 PyObject * obj0 = 0 ;
5221 PyObject * obj1 = 0 ;
5222 char * kwnames[] = {
5223 (char *) "x",(char *) "y", NULL
5224 };
5225
5226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5227 if (obj0) {
5228 ecode1 = SWIG_AsVal_double(obj0, &val1);
5229 if (!SWIG_IsOK(ecode1)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5231 }
5232 arg1 = static_cast< double >(val1);
5233 }
5234 if (obj1) {
5235 ecode2 = SWIG_AsVal_double(obj1, &val2);
5236 if (!SWIG_IsOK(ecode2)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5238 }
5239 arg2 = static_cast< double >(val2);
5240 }
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 void *argp1 = 0 ;
5258 int res1 = 0 ;
5259 PyObject *swig_obj[1] ;
5260
5261 if (!args) SWIG_fail;
5262 swig_obj[0] = args;
5263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5264 if (!SWIG_IsOK(res1)) {
5265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5266 }
5267 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 delete arg1;
5271
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_Py_Void();
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj = 0;
5284 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5285 PyObject *arg2 = (PyObject *) 0 ;
5286 bool result;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 PyObject * obj0 = 0 ;
5290 PyObject * obj1 = 0 ;
5291 char * kwnames[] = {
5292 (char *) "self",(char *) "other", NULL
5293 };
5294
5295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5297 if (!SWIG_IsOK(res1)) {
5298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5299 }
5300 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5301 arg2 = obj1;
5302 {
5303 result = (bool)wxRealPoint___eq__(arg1,arg2);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 {
5307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5308 }
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj = 0;
5317 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5318 PyObject *arg2 = (PyObject *) 0 ;
5319 bool result;
5320 void *argp1 = 0 ;
5321 int res1 = 0 ;
5322 PyObject * obj0 = 0 ;
5323 PyObject * obj1 = 0 ;
5324 char * kwnames[] = {
5325 (char *) "self",(char *) "other", NULL
5326 };
5327
5328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5330 if (!SWIG_IsOK(res1)) {
5331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5332 }
5333 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5334 arg2 = obj1;
5335 {
5336 result = (bool)wxRealPoint___ne__(arg1,arg2);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 {
5340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5341 }
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5349 PyObject *resultobj = 0;
5350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5351 wxRealPoint *arg2 = 0 ;
5352 wxRealPoint result;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 wxRealPoint temp2 ;
5356 PyObject * obj0 = 0 ;
5357 PyObject * obj1 = 0 ;
5358 char * kwnames[] = {
5359 (char *) "self",(char *) "pt", NULL
5360 };
5361
5362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5364 if (!SWIG_IsOK(res1)) {
5365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5366 }
5367 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5368 {
5369 arg2 = &temp2;
5370 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5371 }
5372 {
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5386 PyObject *resultobj = 0;
5387 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5388 wxRealPoint *arg2 = 0 ;
5389 wxRealPoint result;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 wxRealPoint temp2 ;
5393 PyObject * obj0 = 0 ;
5394 PyObject * obj1 = 0 ;
5395 char * kwnames[] = {
5396 (char *) "self",(char *) "pt", NULL
5397 };
5398
5399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5401 if (!SWIG_IsOK(res1)) {
5402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5403 }
5404 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5405 {
5406 arg2 = &temp2;
5407 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5408 }
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj = 0;
5424 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5425 double arg2 ;
5426 double arg3 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 double val2 ;
5430 int ecode2 = 0 ;
5431 double val3 ;
5432 int ecode3 = 0 ;
5433 PyObject * obj0 = 0 ;
5434 PyObject * obj1 = 0 ;
5435 PyObject * obj2 = 0 ;
5436 char * kwnames[] = {
5437 (char *) "self",(char *) "x",(char *) "y", NULL
5438 };
5439
5440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 ecode2 = SWIG_AsVal_double(obj1, &val2);
5447 if (!SWIG_IsOK(ecode2)) {
5448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5449 }
5450 arg2 = static_cast< double >(val2);
5451 ecode3 = SWIG_AsVal_double(obj2, &val3);
5452 if (!SWIG_IsOK(ecode3)) {
5453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5454 }
5455 arg3 = static_cast< double >(val3);
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 wxRealPoint_Set(arg1,arg2,arg3);
5459 wxPyEndAllowThreads(__tstate);
5460 if (PyErr_Occurred()) SWIG_fail;
5461 }
5462 resultobj = SWIG_Py_Void();
5463 return resultobj;
5464 fail:
5465 return NULL;
5466 }
5467
5468
5469 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5470 PyObject *resultobj = 0;
5471 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5472 PyObject *result = 0 ;
5473 void *argp1 = 0 ;
5474 int res1 = 0 ;
5475 PyObject *swig_obj[1] ;
5476
5477 if (!args) SWIG_fail;
5478 swig_obj[0] = args;
5479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5480 if (!SWIG_IsOK(res1)) {
5481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5482 }
5483 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (PyObject *)wxRealPoint_Get(arg1);
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = result;
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5498 PyObject *obj;
5499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5500 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5501 return SWIG_Py_Void();
5502 }
5503
5504 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 return SWIG_Python_InitShadowInstance(args);
5506 }
5507
5508 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5509 PyObject *resultobj = 0;
5510 wxPoint *arg1 = (wxPoint *) 0 ;
5511 int arg2 ;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 int val2 ;
5515 int ecode2 = 0 ;
5516 PyObject *swig_obj[2] ;
5517
5518 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5520 if (!SWIG_IsOK(res1)) {
5521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5522 }
5523 arg1 = reinterpret_cast< wxPoint * >(argp1);
5524 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5525 if (!SWIG_IsOK(ecode2)) {
5526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5527 }
5528 arg2 = static_cast< int >(val2);
5529 if (arg1) (arg1)->x = arg2;
5530
5531 resultobj = SWIG_Py_Void();
5532 return resultobj;
5533 fail:
5534 return NULL;
5535 }
5536
5537
5538 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5539 PyObject *resultobj = 0;
5540 wxPoint *arg1 = (wxPoint *) 0 ;
5541 int result;
5542 void *argp1 = 0 ;
5543 int res1 = 0 ;
5544 PyObject *swig_obj[1] ;
5545
5546 if (!args) SWIG_fail;
5547 swig_obj[0] = args;
5548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5549 if (!SWIG_IsOK(res1)) {
5550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5551 }
5552 arg1 = reinterpret_cast< wxPoint * >(argp1);
5553 result = (int) ((arg1)->x);
5554 resultobj = SWIG_From_int(static_cast< int >(result));
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5562 PyObject *resultobj = 0;
5563 wxPoint *arg1 = (wxPoint *) 0 ;
5564 int arg2 ;
5565 void *argp1 = 0 ;
5566 int res1 = 0 ;
5567 int val2 ;
5568 int ecode2 = 0 ;
5569 PyObject *swig_obj[2] ;
5570
5571 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5573 if (!SWIG_IsOK(res1)) {
5574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5575 }
5576 arg1 = reinterpret_cast< wxPoint * >(argp1);
5577 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5578 if (!SWIG_IsOK(ecode2)) {
5579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5580 }
5581 arg2 = static_cast< int >(val2);
5582 if (arg1) (arg1)->y = arg2;
5583
5584 resultobj = SWIG_Py_Void();
5585 return resultobj;
5586 fail:
5587 return NULL;
5588 }
5589
5590
5591 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5592 PyObject *resultobj = 0;
5593 wxPoint *arg1 = (wxPoint *) 0 ;
5594 int result;
5595 void *argp1 = 0 ;
5596 int res1 = 0 ;
5597 PyObject *swig_obj[1] ;
5598
5599 if (!args) SWIG_fail;
5600 swig_obj[0] = args;
5601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5602 if (!SWIG_IsOK(res1)) {
5603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5604 }
5605 arg1 = reinterpret_cast< wxPoint * >(argp1);
5606 result = (int) ((arg1)->y);
5607 resultobj = SWIG_From_int(static_cast< int >(result));
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj = 0;
5616 int arg1 = (int) 0 ;
5617 int arg2 = (int) 0 ;
5618 wxPoint *result = 0 ;
5619 int val1 ;
5620 int ecode1 = 0 ;
5621 int val2 ;
5622 int ecode2 = 0 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char * kwnames[] = {
5626 (char *) "x",(char *) "y", NULL
5627 };
5628
5629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5630 if (obj0) {
5631 ecode1 = SWIG_AsVal_int(obj0, &val1);
5632 if (!SWIG_IsOK(ecode1)) {
5633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5634 }
5635 arg1 = static_cast< int >(val1);
5636 }
5637 if (obj1) {
5638 ecode2 = SWIG_AsVal_int(obj1, &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5641 }
5642 arg2 = static_cast< int >(val2);
5643 }
5644 {
5645 PyThreadState* __tstate = wxPyBeginAllowThreads();
5646 result = (wxPoint *)new wxPoint(arg1,arg2);
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 void *argp1 = 0 ;
5661 int res1 = 0 ;
5662 PyObject *swig_obj[1] ;
5663
5664 if (!args) SWIG_fail;
5665 swig_obj[0] = args;
5666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5667 if (!SWIG_IsOK(res1)) {
5668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5669 }
5670 arg1 = reinterpret_cast< wxPoint * >(argp1);
5671 {
5672 PyThreadState* __tstate = wxPyBeginAllowThreads();
5673 delete arg1;
5674
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 resultobj = SWIG_Py_Void();
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj = 0;
5687 wxPoint *arg1 = (wxPoint *) 0 ;
5688 PyObject *arg2 = (PyObject *) 0 ;
5689 bool result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 PyObject * obj0 = 0 ;
5693 PyObject * obj1 = 0 ;
5694 char * kwnames[] = {
5695 (char *) "self",(char *) "other", NULL
5696 };
5697
5698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5700 if (!SWIG_IsOK(res1)) {
5701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5702 }
5703 arg1 = reinterpret_cast< wxPoint * >(argp1);
5704 arg2 = obj1;
5705 {
5706 result = (bool)wxPoint___eq__(arg1,arg2);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 {
5710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5711 }
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj = 0;
5720 wxPoint *arg1 = (wxPoint *) 0 ;
5721 PyObject *arg2 = (PyObject *) 0 ;
5722 bool result;
5723 void *argp1 = 0 ;
5724 int res1 = 0 ;
5725 PyObject * obj0 = 0 ;
5726 PyObject * obj1 = 0 ;
5727 char * kwnames[] = {
5728 (char *) "self",(char *) "other", NULL
5729 };
5730
5731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5733 if (!SWIG_IsOK(res1)) {
5734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5735 }
5736 arg1 = reinterpret_cast< wxPoint * >(argp1);
5737 arg2 = obj1;
5738 {
5739 result = (bool)wxPoint___ne__(arg1,arg2);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 {
5743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5744 }
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5752 PyObject *resultobj = 0;
5753 wxPoint *arg1 = (wxPoint *) 0 ;
5754 wxPoint *arg2 = 0 ;
5755 wxPoint result;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 wxPoint temp2 ;
5759 PyObject * obj0 = 0 ;
5760 PyObject * obj1 = 0 ;
5761 char * kwnames[] = {
5762 (char *) "self",(char *) "pt", NULL
5763 };
5764
5765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5767 if (!SWIG_IsOK(res1)) {
5768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5769 }
5770 arg1 = reinterpret_cast< wxPoint * >(argp1);
5771 {
5772 arg2 = &temp2;
5773 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 result = (arg1)->operator +((wxPoint const &)*arg2);
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5782 return resultobj;
5783 fail:
5784 return NULL;
5785 }
5786
5787
5788 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5789 PyObject *resultobj = 0;
5790 wxPoint *arg1 = (wxPoint *) 0 ;
5791 wxPoint *arg2 = 0 ;
5792 wxPoint result;
5793 void *argp1 = 0 ;
5794 int res1 = 0 ;
5795 wxPoint temp2 ;
5796 PyObject * obj0 = 0 ;
5797 PyObject * obj1 = 0 ;
5798 char * kwnames[] = {
5799 (char *) "self",(char *) "pt", NULL
5800 };
5801
5802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5804 if (!SWIG_IsOK(res1)) {
5805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5806 }
5807 arg1 = reinterpret_cast< wxPoint * >(argp1);
5808 {
5809 arg2 = &temp2;
5810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5811 }
5812 {
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 result = (arg1)->operator -((wxPoint const &)*arg2);
5815 wxPyEndAllowThreads(__tstate);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj = 0;
5827 wxPoint *arg1 = (wxPoint *) 0 ;
5828 wxPoint *arg2 = 0 ;
5829 wxPoint *result = 0 ;
5830 void *argp1 = 0 ;
5831 int res1 = 0 ;
5832 wxPoint temp2 ;
5833 PyObject * obj0 = 0 ;
5834 PyObject * obj1 = 0 ;
5835 char * kwnames[] = {
5836 (char *) "self",(char *) "pt", NULL
5837 };
5838
5839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5841 if (!SWIG_IsOK(res1)) {
5842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5843 }
5844 arg1 = reinterpret_cast< wxPoint * >(argp1);
5845 {
5846 arg2 = &temp2;
5847 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 {
5852 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5853 result = (wxPoint *) &_result_ref;
5854 }
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxPoint *arg1 = (wxPoint *) 0 ;
5868 wxPoint *arg2 = 0 ;
5869 wxPoint *result = 0 ;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 wxPoint temp2 ;
5873 PyObject * obj0 = 0 ;
5874 PyObject * obj1 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "self",(char *) "pt", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 arg2 = &temp2;
5887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5888 }
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 {
5892 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5893 result = (wxPoint *) &_result_ref;
5894 }
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj = 0;
5907 wxPoint *arg1 = (wxPoint *) 0 ;
5908 long arg2 ;
5909 long arg3 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 long val2 ;
5913 int ecode2 = 0 ;
5914 long val3 ;
5915 int ecode3 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 PyObject * obj2 = 0 ;
5919 char * kwnames[] = {
5920 (char *) "self",(char *) "x",(char *) "y", NULL
5921 };
5922
5923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5925 if (!SWIG_IsOK(res1)) {
5926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5927 }
5928 arg1 = reinterpret_cast< wxPoint * >(argp1);
5929 ecode2 = SWIG_AsVal_long(obj1, &val2);
5930 if (!SWIG_IsOK(ecode2)) {
5931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5932 }
5933 arg2 = static_cast< long >(val2);
5934 ecode3 = SWIG_AsVal_long(obj2, &val3);
5935 if (!SWIG_IsOK(ecode3)) {
5936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5937 }
5938 arg3 = static_cast< long >(val3);
5939 {
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 wxPoint_Set(arg1,arg2,arg3);
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 resultobj = SWIG_Py_Void();
5946 return resultobj;
5947 fail:
5948 return NULL;
5949 }
5950
5951
5952 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5953 PyObject *resultobj = 0;
5954 wxPoint *arg1 = (wxPoint *) 0 ;
5955 PyObject *result = 0 ;
5956 void *argp1 = 0 ;
5957 int res1 = 0 ;
5958 PyObject *swig_obj[1] ;
5959
5960 if (!args) SWIG_fail;
5961 swig_obj[0] = args;
5962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5963 if (!SWIG_IsOK(res1)) {
5964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5965 }
5966 arg1 = reinterpret_cast< wxPoint * >(argp1);
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (PyObject *)wxPoint_Get(arg1);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = result;
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5981 PyObject *obj;
5982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5983 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5984 return SWIG_Py_Void();
5985 }
5986
5987 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5988 return SWIG_Python_InitShadowInstance(args);
5989 }
5990
5991 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj = 0;
5993 int arg1 = (int) 0 ;
5994 int arg2 = (int) 0 ;
5995 int arg3 = (int) 0 ;
5996 int arg4 = (int) 0 ;
5997 wxRect *result = 0 ;
5998 int val1 ;
5999 int ecode1 = 0 ;
6000 int val2 ;
6001 int ecode2 = 0 ;
6002 int val3 ;
6003 int ecode3 = 0 ;
6004 int val4 ;
6005 int ecode4 = 0 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 PyObject * obj2 = 0 ;
6009 PyObject * obj3 = 0 ;
6010 char * kwnames[] = {
6011 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6012 };
6013
6014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6015 if (obj0) {
6016 ecode1 = SWIG_AsVal_int(obj0, &val1);
6017 if (!SWIG_IsOK(ecode1)) {
6018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6019 }
6020 arg1 = static_cast< int >(val1);
6021 }
6022 if (obj1) {
6023 ecode2 = SWIG_AsVal_int(obj1, &val2);
6024 if (!SWIG_IsOK(ecode2)) {
6025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6026 }
6027 arg2 = static_cast< int >(val2);
6028 }
6029 if (obj2) {
6030 ecode3 = SWIG_AsVal_int(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6033 }
6034 arg3 = static_cast< int >(val3);
6035 }
6036 if (obj3) {
6037 ecode4 = SWIG_AsVal_int(obj3, &val4);
6038 if (!SWIG_IsOK(ecode4)) {
6039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6040 }
6041 arg4 = static_cast< int >(val4);
6042 }
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6057 PyObject *resultobj = 0;
6058 wxPoint *arg1 = 0 ;
6059 wxPoint *arg2 = 0 ;
6060 wxRect *result = 0 ;
6061 wxPoint temp1 ;
6062 wxPoint temp2 ;
6063 PyObject * obj0 = 0 ;
6064 PyObject * obj1 = 0 ;
6065 char * kwnames[] = {
6066 (char *) "topLeft",(char *) "bottomRight", NULL
6067 };
6068
6069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6070 {
6071 arg1 = &temp1;
6072 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6073 }
6074 {
6075 arg2 = &temp2;
6076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6081 wxPyEndAllowThreads(__tstate);
6082 if (PyErr_Occurred()) SWIG_fail;
6083 }
6084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6085 return resultobj;
6086 fail:
6087 return NULL;
6088 }
6089
6090
6091 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6092 PyObject *resultobj = 0;
6093 wxPoint *arg1 = 0 ;
6094 wxSize *arg2 = 0 ;
6095 wxRect *result = 0 ;
6096 wxPoint temp1 ;
6097 wxSize temp2 ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 char * kwnames[] = {
6101 (char *) "pos",(char *) "size", NULL
6102 };
6103
6104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6105 {
6106 arg1 = &temp1;
6107 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6108 }
6109 {
6110 arg2 = &temp2;
6111 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6112 }
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj = 0;
6128 wxSize *arg1 = 0 ;
6129 wxRect *result = 0 ;
6130 wxSize temp1 ;
6131 PyObject * obj0 = 0 ;
6132 char * kwnames[] = {
6133 (char *) "size", NULL
6134 };
6135
6136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6137 {
6138 arg1 = &temp1;
6139 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6140 }
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *resultobj = 0;
6156 wxRect *arg1 = (wxRect *) 0 ;
6157 void *argp1 = 0 ;
6158 int res1 = 0 ;
6159 PyObject *swig_obj[1] ;
6160
6161 if (!args) SWIG_fail;
6162 swig_obj[0] = args;
6163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6164 if (!SWIG_IsOK(res1)) {
6165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6166 }
6167 arg1 = reinterpret_cast< wxRect * >(argp1);
6168 {
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 delete arg1;
6171
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_Py_Void();
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6183 PyObject *resultobj = 0;
6184 wxRect *arg1 = (wxRect *) 0 ;
6185 int result;
6186 void *argp1 = 0 ;
6187 int res1 = 0 ;
6188 PyObject *swig_obj[1] ;
6189
6190 if (!args) SWIG_fail;
6191 swig_obj[0] = args;
6192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6193 if (!SWIG_IsOK(res1)) {
6194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6195 }
6196 arg1 = reinterpret_cast< wxRect * >(argp1);
6197 {
6198 PyThreadState* __tstate = wxPyBeginAllowThreads();
6199 result = (int)((wxRect const *)arg1)->GetX();
6200 wxPyEndAllowThreads(__tstate);
6201 if (PyErr_Occurred()) SWIG_fail;
6202 }
6203 resultobj = SWIG_From_int(static_cast< int >(result));
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj = 0;
6212 wxRect *arg1 = (wxRect *) 0 ;
6213 int arg2 ;
6214 void *argp1 = 0 ;
6215 int res1 = 0 ;
6216 int val2 ;
6217 int ecode2 = 0 ;
6218 PyObject * obj0 = 0 ;
6219 PyObject * obj1 = 0 ;
6220 char * kwnames[] = {
6221 (char *) "self",(char *) "x", NULL
6222 };
6223
6224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6226 if (!SWIG_IsOK(res1)) {
6227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6228 }
6229 arg1 = reinterpret_cast< wxRect * >(argp1);
6230 ecode2 = SWIG_AsVal_int(obj1, &val2);
6231 if (!SWIG_IsOK(ecode2)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6233 }
6234 arg2 = static_cast< int >(val2);
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 (arg1)->SetX(arg2);
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 resultobj = SWIG_Py_Void();
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6249 PyObject *resultobj = 0;
6250 wxRect *arg1 = (wxRect *) 0 ;
6251 int result;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 PyObject *swig_obj[1] ;
6255
6256 if (!args) SWIG_fail;
6257 swig_obj[0] = args;
6258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6261 }
6262 arg1 = reinterpret_cast< wxRect * >(argp1);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 result = (int)(arg1)->GetY();
6266 wxPyEndAllowThreads(__tstate);
6267 if (PyErr_Occurred()) SWIG_fail;
6268 }
6269 resultobj = SWIG_From_int(static_cast< int >(result));
6270 return resultobj;
6271 fail:
6272 return NULL;
6273 }
6274
6275
6276 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6277 PyObject *resultobj = 0;
6278 wxRect *arg1 = (wxRect *) 0 ;
6279 int arg2 ;
6280 void *argp1 = 0 ;
6281 int res1 = 0 ;
6282 int val2 ;
6283 int ecode2 = 0 ;
6284 PyObject * obj0 = 0 ;
6285 PyObject * obj1 = 0 ;
6286 char * kwnames[] = {
6287 (char *) "self",(char *) "y", NULL
6288 };
6289
6290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6292 if (!SWIG_IsOK(res1)) {
6293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6294 }
6295 arg1 = reinterpret_cast< wxRect * >(argp1);
6296 ecode2 = SWIG_AsVal_int(obj1, &val2);
6297 if (!SWIG_IsOK(ecode2)) {
6298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6299 }
6300 arg2 = static_cast< int >(val2);
6301 {
6302 PyThreadState* __tstate = wxPyBeginAllowThreads();
6303 (arg1)->SetY(arg2);
6304 wxPyEndAllowThreads(__tstate);
6305 if (PyErr_Occurred()) SWIG_fail;
6306 }
6307 resultobj = SWIG_Py_Void();
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6315 PyObject *resultobj = 0;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int result;
6318 void *argp1 = 0 ;
6319 int res1 = 0 ;
6320 PyObject *swig_obj[1] ;
6321
6322 if (!args) SWIG_fail;
6323 swig_obj[0] = args;
6324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6325 if (!SWIG_IsOK(res1)) {
6326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6327 }
6328 arg1 = reinterpret_cast< wxRect * >(argp1);
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 result = (int)((wxRect const *)arg1)->GetWidth();
6332 wxPyEndAllowThreads(__tstate);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 resultobj = SWIG_From_int(static_cast< int >(result));
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj = 0;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 int arg2 ;
6346 void *argp1 = 0 ;
6347 int res1 = 0 ;
6348 int val2 ;
6349 int ecode2 = 0 ;
6350 PyObject * obj0 = 0 ;
6351 PyObject * obj1 = 0 ;
6352 char * kwnames[] = {
6353 (char *) "self",(char *) "w", NULL
6354 };
6355
6356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6358 if (!SWIG_IsOK(res1)) {
6359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6360 }
6361 arg1 = reinterpret_cast< wxRect * >(argp1);
6362 ecode2 = SWIG_AsVal_int(obj1, &val2);
6363 if (!SWIG_IsOK(ecode2)) {
6364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6365 }
6366 arg2 = static_cast< int >(val2);
6367 {
6368 PyThreadState* __tstate = wxPyBeginAllowThreads();
6369 (arg1)->SetWidth(arg2);
6370 wxPyEndAllowThreads(__tstate);
6371 if (PyErr_Occurred()) SWIG_fail;
6372 }
6373 resultobj = SWIG_Py_Void();
6374 return resultobj;
6375 fail:
6376 return NULL;
6377 }
6378
6379
6380 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6381 PyObject *resultobj = 0;
6382 wxRect *arg1 = (wxRect *) 0 ;
6383 int result;
6384 void *argp1 = 0 ;
6385 int res1 = 0 ;
6386 PyObject *swig_obj[1] ;
6387
6388 if (!args) SWIG_fail;
6389 swig_obj[0] = args;
6390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6391 if (!SWIG_IsOK(res1)) {
6392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6393 }
6394 arg1 = reinterpret_cast< wxRect * >(argp1);
6395 {
6396 PyThreadState* __tstate = wxPyBeginAllowThreads();
6397 result = (int)((wxRect const *)arg1)->GetHeight();
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 resultobj = SWIG_From_int(static_cast< int >(result));
6402 return resultobj;
6403 fail:
6404 return NULL;
6405 }
6406
6407
6408 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6409 PyObject *resultobj = 0;
6410 wxRect *arg1 = (wxRect *) 0 ;
6411 int arg2 ;
6412 void *argp1 = 0 ;
6413 int res1 = 0 ;
6414 int val2 ;
6415 int ecode2 = 0 ;
6416 PyObject * obj0 = 0 ;
6417 PyObject * obj1 = 0 ;
6418 char * kwnames[] = {
6419 (char *) "self",(char *) "h", NULL
6420 };
6421
6422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6424 if (!SWIG_IsOK(res1)) {
6425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6426 }
6427 arg1 = reinterpret_cast< wxRect * >(argp1);
6428 ecode2 = SWIG_AsVal_int(obj1, &val2);
6429 if (!SWIG_IsOK(ecode2)) {
6430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6431 }
6432 arg2 = static_cast< int >(val2);
6433 {
6434 PyThreadState* __tstate = wxPyBeginAllowThreads();
6435 (arg1)->SetHeight(arg2);
6436 wxPyEndAllowThreads(__tstate);
6437 if (PyErr_Occurred()) SWIG_fail;
6438 }
6439 resultobj = SWIG_Py_Void();
6440 return resultobj;
6441 fail:
6442 return NULL;
6443 }
6444
6445
6446 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6447 PyObject *resultobj = 0;
6448 wxRect *arg1 = (wxRect *) 0 ;
6449 wxPoint result;
6450 void *argp1 = 0 ;
6451 int res1 = 0 ;
6452 PyObject *swig_obj[1] ;
6453
6454 if (!args) SWIG_fail;
6455 swig_obj[0] = args;
6456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6457 if (!SWIG_IsOK(res1)) {
6458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6459 }
6460 arg1 = reinterpret_cast< wxRect * >(argp1);
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 result = ((wxRect const *)arg1)->GetPosition();
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj = 0;
6476 wxRect *arg1 = (wxRect *) 0 ;
6477 wxPoint *arg2 = 0 ;
6478 void *argp1 = 0 ;
6479 int res1 = 0 ;
6480 wxPoint temp2 ;
6481 PyObject * obj0 = 0 ;
6482 PyObject * obj1 = 0 ;
6483 char * kwnames[] = {
6484 (char *) "self",(char *) "p", NULL
6485 };
6486
6487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6489 if (!SWIG_IsOK(res1)) {
6490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6491 }
6492 arg1 = reinterpret_cast< wxRect * >(argp1);
6493 {
6494 arg2 = &temp2;
6495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6496 }
6497 {
6498 PyThreadState* __tstate = wxPyBeginAllowThreads();
6499 (arg1)->SetPosition((wxPoint const &)*arg2);
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 resultobj = SWIG_Py_Void();
6504 return resultobj;
6505 fail:
6506 return NULL;
6507 }
6508
6509
6510 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6511 PyObject *resultobj = 0;
6512 wxRect *arg1 = (wxRect *) 0 ;
6513 wxSize result;
6514 void *argp1 = 0 ;
6515 int res1 = 0 ;
6516 PyObject *swig_obj[1] ;
6517
6518 if (!args) SWIG_fail;
6519 swig_obj[0] = args;
6520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6521 if (!SWIG_IsOK(res1)) {
6522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6523 }
6524 arg1 = reinterpret_cast< wxRect * >(argp1);
6525 {
6526 PyThreadState* __tstate = wxPyBeginAllowThreads();
6527 result = ((wxRect const *)arg1)->GetSize();
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 wxSize *arg2 = 0 ;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 wxSize temp2 ;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 char * kwnames[] = {
6548 (char *) "self",(char *) "s", NULL
6549 };
6550
6551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",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_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 arg2 = &temp2;
6559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6560 }
6561 {
6562 PyThreadState* __tstate = wxPyBeginAllowThreads();
6563 (arg1)->SetSize((wxSize const &)*arg2);
6564 wxPyEndAllowThreads(__tstate);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_Py_Void();
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxRect *arg1 = (wxRect *) 0 ;
6577 bool result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = (bool)((wxRect const *)arg1)->IsEmpty();
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 {
6596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6597 }
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6605 PyObject *resultobj = 0;
6606 wxRect *arg1 = (wxRect *) 0 ;
6607 wxPoint result;
6608 void *argp1 = 0 ;
6609 int res1 = 0 ;
6610 PyObject *swig_obj[1] ;
6611
6612 if (!args) SWIG_fail;
6613 swig_obj[0] = args;
6614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 {
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = ((wxRect const *)arg1)->GetTopLeft();
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 wxPoint *arg2 = 0 ;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 wxPoint temp2 ;
6639 PyObject * obj0 = 0 ;
6640 PyObject * obj1 = 0 ;
6641 char * kwnames[] = {
6642 (char *) "self",(char *) "p", NULL
6643 };
6644
6645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 arg2 = &temp2;
6653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6654 }
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 resultobj = SWIG_Py_Void();
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6669 PyObject *resultobj = 0;
6670 wxRect *arg1 = (wxRect *) 0 ;
6671 wxPoint result;
6672 void *argp1 = 0 ;
6673 int res1 = 0 ;
6674 PyObject *swig_obj[1] ;
6675
6676 if (!args) SWIG_fail;
6677 swig_obj[0] = args;
6678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6679 if (!SWIG_IsOK(res1)) {
6680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6681 }
6682 arg1 = reinterpret_cast< wxRect * >(argp1);
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 result = ((wxRect const *)arg1)->GetBottomRight();
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxPoint *arg2 = 0 ;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 wxPoint temp2 ;
6703 PyObject * obj0 = 0 ;
6704 PyObject * obj1 = 0 ;
6705 char * kwnames[] = {
6706 (char *) "self",(char *) "p", NULL
6707 };
6708
6709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 arg2 = &temp2;
6717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6718 }
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_Py_Void();
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6733 PyObject *resultobj = 0;
6734 wxRect *arg1 = (wxRect *) 0 ;
6735 int result;
6736 void *argp1 = 0 ;
6737 int res1 = 0 ;
6738 PyObject *swig_obj[1] ;
6739
6740 if (!args) SWIG_fail;
6741 swig_obj[0] = args;
6742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 result = (int)((wxRect const *)arg1)->GetLeft();
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 resultobj = SWIG_From_int(static_cast< int >(result));
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxRect *arg1 = (wxRect *) 0 ;
6763 int result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6773 }
6774 arg1 = reinterpret_cast< wxRect * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (int)((wxRect const *)arg1)->GetTop();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_From_int(static_cast< int >(result));
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6789 PyObject *resultobj = 0;
6790 wxRect *arg1 = (wxRect *) 0 ;
6791 int result;
6792 void *argp1 = 0 ;
6793 int res1 = 0 ;
6794 PyObject *swig_obj[1] ;
6795
6796 if (!args) SWIG_fail;
6797 swig_obj[0] = args;
6798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6799 if (!SWIG_IsOK(res1)) {
6800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6801 }
6802 arg1 = reinterpret_cast< wxRect * >(argp1);
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 result = (int)((wxRect const *)arg1)->GetBottom();
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_From_int(static_cast< int >(result));
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6817 PyObject *resultobj = 0;
6818 wxRect *arg1 = (wxRect *) 0 ;
6819 int result;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 PyObject *swig_obj[1] ;
6823
6824 if (!args) SWIG_fail;
6825 swig_obj[0] = args;
6826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6827 if (!SWIG_IsOK(res1)) {
6828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6829 }
6830 arg1 = reinterpret_cast< wxRect * >(argp1);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (int)((wxRect const *)arg1)->GetRight();
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_From_int(static_cast< int >(result));
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 int arg2 ;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 int val2 ;
6851 int ecode2 = 0 ;
6852 PyObject * obj0 = 0 ;
6853 PyObject * obj1 = 0 ;
6854 char * kwnames[] = {
6855 (char *) "self",(char *) "left", NULL
6856 };
6857
6858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6860 if (!SWIG_IsOK(res1)) {
6861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6862 }
6863 arg1 = reinterpret_cast< wxRect * >(argp1);
6864 ecode2 = SWIG_AsVal_int(obj1, &val2);
6865 if (!SWIG_IsOK(ecode2)) {
6866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6867 }
6868 arg2 = static_cast< int >(val2);
6869 {
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 (arg1)->SetLeft(arg2);
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_Py_Void();
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj = 0;
6884 wxRect *arg1 = (wxRect *) 0 ;
6885 int arg2 ;
6886 void *argp1 = 0 ;
6887 int res1 = 0 ;
6888 int val2 ;
6889 int ecode2 = 0 ;
6890 PyObject * obj0 = 0 ;
6891 PyObject * obj1 = 0 ;
6892 char * kwnames[] = {
6893 (char *) "self",(char *) "right", NULL
6894 };
6895
6896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6898 if (!SWIG_IsOK(res1)) {
6899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6900 }
6901 arg1 = reinterpret_cast< wxRect * >(argp1);
6902 ecode2 = SWIG_AsVal_int(obj1, &val2);
6903 if (!SWIG_IsOK(ecode2)) {
6904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6905 }
6906 arg2 = static_cast< int >(val2);
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 (arg1)->SetRight(arg2);
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_Py_Void();
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = 0;
6922 wxRect *arg1 = (wxRect *) 0 ;
6923 int arg2 ;
6924 void *argp1 = 0 ;
6925 int res1 = 0 ;
6926 int val2 ;
6927 int ecode2 = 0 ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "self",(char *) "top", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 ecode2 = SWIG_AsVal_int(obj1, &val2);
6941 if (!SWIG_IsOK(ecode2)) {
6942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6943 }
6944 arg2 = static_cast< int >(val2);
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 (arg1)->SetTop(arg2);
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_Py_Void();
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj = 0;
6960 wxRect *arg1 = (wxRect *) 0 ;
6961 int arg2 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 int val2 ;
6965 int ecode2 = 0 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "self",(char *) "bottom", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 ecode2 = SWIG_AsVal_int(obj1, &val2);
6979 if (!SWIG_IsOK(ecode2)) {
6980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6981 }
6982 arg2 = static_cast< int >(val2);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 (arg1)->SetBottom(arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_Py_Void();
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj = 0;
6998 wxRect *arg1 = (wxRect *) 0 ;
6999 int arg2 ;
7000 int arg3 ;
7001 wxRect *result = 0 ;
7002 void *argp1 = 0 ;
7003 int res1 = 0 ;
7004 int val2 ;
7005 int ecode2 = 0 ;
7006 int val3 ;
7007 int ecode3 = 0 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 PyObject * obj2 = 0 ;
7011 char * kwnames[] = {
7012 (char *) "self",(char *) "dx",(char *) "dy", NULL
7013 };
7014
7015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7017 if (!SWIG_IsOK(res1)) {
7018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7019 }
7020 arg1 = reinterpret_cast< wxRect * >(argp1);
7021 ecode2 = SWIG_AsVal_int(obj1, &val2);
7022 if (!SWIG_IsOK(ecode2)) {
7023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7024 }
7025 arg2 = static_cast< int >(val2);
7026 ecode3 = SWIG_AsVal_int(obj2, &val3);
7027 if (!SWIG_IsOK(ecode3)) {
7028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7029 }
7030 arg3 = static_cast< int >(val3);
7031 {
7032 PyThreadState* __tstate = wxPyBeginAllowThreads();
7033 {
7034 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7035 result = (wxRect *) &_result_ref;
7036 }
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7041 return resultobj;
7042 fail:
7043 return NULL;
7044 }
7045
7046
7047 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7048 PyObject *resultobj = 0;
7049 wxRect *arg1 = (wxRect *) 0 ;
7050 int arg2 ;
7051 int arg3 ;
7052 wxRect *result = 0 ;
7053 void *argp1 = 0 ;
7054 int res1 = 0 ;
7055 int val2 ;
7056 int ecode2 = 0 ;
7057 int val3 ;
7058 int ecode3 = 0 ;
7059 PyObject * obj0 = 0 ;
7060 PyObject * obj1 = 0 ;
7061 PyObject * obj2 = 0 ;
7062 char * kwnames[] = {
7063 (char *) "self",(char *) "dx",(char *) "dy", NULL
7064 };
7065
7066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7068 if (!SWIG_IsOK(res1)) {
7069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7070 }
7071 arg1 = reinterpret_cast< wxRect * >(argp1);
7072 ecode2 = SWIG_AsVal_int(obj1, &val2);
7073 if (!SWIG_IsOK(ecode2)) {
7074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7075 }
7076 arg2 = static_cast< int >(val2);
7077 ecode3 = SWIG_AsVal_int(obj2, &val3);
7078 if (!SWIG_IsOK(ecode3)) {
7079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7080 }
7081 arg3 = static_cast< int >(val3);
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 {
7085 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7086 result = (wxRect *) &_result_ref;
7087 }
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7099 PyObject *resultobj = 0;
7100 wxRect *arg1 = (wxRect *) 0 ;
7101 int arg2 ;
7102 int arg3 ;
7103 void *argp1 = 0 ;
7104 int res1 = 0 ;
7105 int val2 ;
7106 int ecode2 = 0 ;
7107 int val3 ;
7108 int ecode3 = 0 ;
7109 PyObject * obj0 = 0 ;
7110 PyObject * obj1 = 0 ;
7111 PyObject * obj2 = 0 ;
7112 char * kwnames[] = {
7113 (char *) "self",(char *) "dx",(char *) "dy", NULL
7114 };
7115
7116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7118 if (!SWIG_IsOK(res1)) {
7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7120 }
7121 arg1 = reinterpret_cast< wxRect * >(argp1);
7122 ecode2 = SWIG_AsVal_int(obj1, &val2);
7123 if (!SWIG_IsOK(ecode2)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7125 }
7126 arg2 = static_cast< int >(val2);
7127 ecode3 = SWIG_AsVal_int(obj2, &val3);
7128 if (!SWIG_IsOK(ecode3)) {
7129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7130 }
7131 arg3 = static_cast< int >(val3);
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 (arg1)->Offset(arg2,arg3);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_Py_Void();
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxRect *arg1 = (wxRect *) 0 ;
7148 wxPoint *arg2 = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 wxPoint temp2 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char * kwnames[] = {
7155 (char *) "self",(char *) "pt", NULL
7156 };
7157
7158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7162 }
7163 arg1 = reinterpret_cast< wxRect * >(argp1);
7164 {
7165 arg2 = &temp2;
7166 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7167 }
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 (arg1)->Offset((wxPoint const &)*arg2);
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 resultobj = SWIG_Py_Void();
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj = 0;
7183 wxRect *arg1 = (wxRect *) 0 ;
7184 wxRect *arg2 = 0 ;
7185 wxRect result;
7186 void *argp1 = 0 ;
7187 int res1 = 0 ;
7188 wxRect temp2 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 char * kwnames[] = {
7192 (char *) "self",(char *) "rect", NULL
7193 };
7194
7195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7197 if (!SWIG_IsOK(res1)) {
7198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7199 }
7200 arg1 = reinterpret_cast< wxRect * >(argp1);
7201 {
7202 arg2 = &temp2;
7203 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7204 }
7205 {
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 result = (arg1)->Intersect((wxRect const &)*arg2);
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj = 0;
7220 wxRect *arg1 = (wxRect *) 0 ;
7221 wxRect *arg2 = 0 ;
7222 wxRect result;
7223 void *argp1 = 0 ;
7224 int res1 = 0 ;
7225 wxRect temp2 ;
7226 PyObject * obj0 = 0 ;
7227 PyObject * obj1 = 0 ;
7228 char * kwnames[] = {
7229 (char *) "self",(char *) "rect", NULL
7230 };
7231
7232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7234 if (!SWIG_IsOK(res1)) {
7235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7236 }
7237 arg1 = reinterpret_cast< wxRect * >(argp1);
7238 {
7239 arg2 = &temp2;
7240 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7241 }
7242 {
7243 PyThreadState* __tstate = wxPyBeginAllowThreads();
7244 result = (arg1)->Union((wxRect const &)*arg2);
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj = 0;
7257 wxRect *arg1 = (wxRect *) 0 ;
7258 wxRect *arg2 = 0 ;
7259 wxRect result;
7260 void *argp1 = 0 ;
7261 int res1 = 0 ;
7262 wxRect temp2 ;
7263 PyObject * obj0 = 0 ;
7264 PyObject * obj1 = 0 ;
7265 char * kwnames[] = {
7266 (char *) "self",(char *) "rect", NULL
7267 };
7268
7269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7271 if (!SWIG_IsOK(res1)) {
7272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7273 }
7274 arg1 = reinterpret_cast< wxRect * >(argp1);
7275 {
7276 arg2 = &temp2;
7277 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7278 }
7279 {
7280 PyThreadState* __tstate = wxPyBeginAllowThreads();
7281 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj = 0;
7294 wxRect *arg1 = (wxRect *) 0 ;
7295 wxRect *arg2 = 0 ;
7296 wxRect *result = 0 ;
7297 void *argp1 = 0 ;
7298 int res1 = 0 ;
7299 wxRect temp2 ;
7300 PyObject * obj0 = 0 ;
7301 PyObject * obj1 = 0 ;
7302 char * kwnames[] = {
7303 (char *) "self",(char *) "rect", NULL
7304 };
7305
7306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7308 if (!SWIG_IsOK(res1)) {
7309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7310 }
7311 arg1 = reinterpret_cast< wxRect * >(argp1);
7312 {
7313 arg2 = &temp2;
7314 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7315 }
7316 {
7317 PyThreadState* __tstate = wxPyBeginAllowThreads();
7318 {
7319 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7320 result = (wxRect *) &_result_ref;
7321 }
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj = 0;
7334 wxRect *arg1 = (wxRect *) 0 ;
7335 PyObject *arg2 = (PyObject *) 0 ;
7336 bool result;
7337 void *argp1 = 0 ;
7338 int res1 = 0 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "other", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7349 }
7350 arg1 = reinterpret_cast< wxRect * >(argp1);
7351 arg2 = obj1;
7352 {
7353 result = (bool)wxRect___eq__(arg1,arg2);
7354 if (PyErr_Occurred()) SWIG_fail;
7355 }
7356 {
7357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7358 }
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj = 0;
7367 wxRect *arg1 = (wxRect *) 0 ;
7368 PyObject *arg2 = (PyObject *) 0 ;
7369 bool result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject * obj0 = 0 ;
7373 PyObject * obj1 = 0 ;
7374 char * kwnames[] = {
7375 (char *) "self",(char *) "other", NULL
7376 };
7377
7378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7380 if (!SWIG_IsOK(res1)) {
7381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7382 }
7383 arg1 = reinterpret_cast< wxRect * >(argp1);
7384 arg2 = obj1;
7385 {
7386 result = (bool)wxRect___ne__(arg1,arg2);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 {
7390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7391 }
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj = 0;
7400 wxRect *arg1 = (wxRect *) 0 ;
7401 int arg2 ;
7402 int arg3 ;
7403 bool result;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 int val2 ;
7407 int ecode2 = 0 ;
7408 int val3 ;
7409 int ecode3 = 0 ;
7410 PyObject * obj0 = 0 ;
7411 PyObject * obj1 = 0 ;
7412 PyObject * obj2 = 0 ;
7413 char * kwnames[] = {
7414 (char *) "self",(char *) "x",(char *) "y", NULL
7415 };
7416
7417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7419 if (!SWIG_IsOK(res1)) {
7420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7421 }
7422 arg1 = reinterpret_cast< wxRect * >(argp1);
7423 ecode2 = SWIG_AsVal_int(obj1, &val2);
7424 if (!SWIG_IsOK(ecode2)) {
7425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7426 }
7427 arg2 = static_cast< int >(val2);
7428 ecode3 = SWIG_AsVal_int(obj2, &val3);
7429 if (!SWIG_IsOK(ecode3)) {
7430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7431 }
7432 arg3 = static_cast< int >(val3);
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 {
7440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7441 }
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxPoint *arg2 = 0 ;
7452 bool result;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxPoint temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "pt", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",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_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj = 0;
7489 wxRect *arg1 = (wxRect *) 0 ;
7490 wxRect *arg2 = 0 ;
7491 bool result;
7492 void *argp1 = 0 ;
7493 int res1 = 0 ;
7494 wxRect temp2 ;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 char * kwnames[] = {
7498 (char *) "self",(char *) "rect", NULL
7499 };
7500
7501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7503 if (!SWIG_IsOK(res1)) {
7504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7505 }
7506 arg1 = reinterpret_cast< wxRect * >(argp1);
7507 {
7508 arg2 = &temp2;
7509 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7510 }
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 {
7518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7519 }
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7527 PyObject *resultobj = 0;
7528 wxRect *arg1 = (wxRect *) 0 ;
7529 wxRect *arg2 = 0 ;
7530 int arg3 = (int) wxBOTH ;
7531 wxRect result;
7532 void *argp1 = 0 ;
7533 int res1 = 0 ;
7534 wxRect temp2 ;
7535 int val3 ;
7536 int ecode3 = 0 ;
7537 PyObject * obj0 = 0 ;
7538 PyObject * obj1 = 0 ;
7539 PyObject * obj2 = 0 ;
7540 char * kwnames[] = {
7541 (char *) "self",(char *) "r",(char *) "dir", NULL
7542 };
7543
7544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7546 if (!SWIG_IsOK(res1)) {
7547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7548 }
7549 arg1 = reinterpret_cast< wxRect * >(argp1);
7550 {
7551 arg2 = &temp2;
7552 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7553 }
7554 if (obj2) {
7555 ecode3 = SWIG_AsVal_int(obj2, &val3);
7556 if (!SWIG_IsOK(ecode3)) {
7557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7558 }
7559 arg3 = static_cast< int >(val3);
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 int arg2 ;
7578 void *argp1 = 0 ;
7579 int res1 = 0 ;
7580 int val2 ;
7581 int ecode2 = 0 ;
7582 PyObject *swig_obj[2] ;
7583
7584 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7586 if (!SWIG_IsOK(res1)) {
7587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7588 }
7589 arg1 = reinterpret_cast< wxRect * >(argp1);
7590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7591 if (!SWIG_IsOK(ecode2)) {
7592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7593 }
7594 arg2 = static_cast< int >(val2);
7595 if (arg1) (arg1)->x = arg2;
7596
7597 resultobj = SWIG_Py_Void();
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7605 PyObject *resultobj = 0;
7606 wxRect *arg1 = (wxRect *) 0 ;
7607 int result;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 PyObject *swig_obj[1] ;
7611
7612 if (!args) SWIG_fail;
7613 swig_obj[0] = args;
7614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7617 }
7618 arg1 = reinterpret_cast< wxRect * >(argp1);
7619 result = (int) ((arg1)->x);
7620 resultobj = SWIG_From_int(static_cast< int >(result));
7621 return resultobj;
7622 fail:
7623 return NULL;
7624 }
7625
7626
7627 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7628 PyObject *resultobj = 0;
7629 wxRect *arg1 = (wxRect *) 0 ;
7630 int arg2 ;
7631 void *argp1 = 0 ;
7632 int res1 = 0 ;
7633 int val2 ;
7634 int ecode2 = 0 ;
7635 PyObject *swig_obj[2] ;
7636
7637 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7644 if (!SWIG_IsOK(ecode2)) {
7645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7646 }
7647 arg2 = static_cast< int >(val2);
7648 if (arg1) (arg1)->y = arg2;
7649
7650 resultobj = SWIG_Py_Void();
7651 return resultobj;
7652 fail:
7653 return NULL;
7654 }
7655
7656
7657 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7658 PyObject *resultobj = 0;
7659 wxRect *arg1 = (wxRect *) 0 ;
7660 int result;
7661 void *argp1 = 0 ;
7662 int res1 = 0 ;
7663 PyObject *swig_obj[1] ;
7664
7665 if (!args) SWIG_fail;
7666 swig_obj[0] = args;
7667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7668 if (!SWIG_IsOK(res1)) {
7669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7670 }
7671 arg1 = reinterpret_cast< wxRect * >(argp1);
7672 result = (int) ((arg1)->y);
7673 resultobj = SWIG_From_int(static_cast< int >(result));
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 int arg2 ;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 int val2 ;
7687 int ecode2 = 0 ;
7688 PyObject *swig_obj[2] ;
7689
7690 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7694 }
7695 arg1 = reinterpret_cast< wxRect * >(argp1);
7696 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7697 if (!SWIG_IsOK(ecode2)) {
7698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7699 }
7700 arg2 = static_cast< int >(val2);
7701 if (arg1) (arg1)->width = arg2;
7702
7703 resultobj = SWIG_Py_Void();
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7711 PyObject *resultobj = 0;
7712 wxRect *arg1 = (wxRect *) 0 ;
7713 int result;
7714 void *argp1 = 0 ;
7715 int res1 = 0 ;
7716 PyObject *swig_obj[1] ;
7717
7718 if (!args) SWIG_fail;
7719 swig_obj[0] = args;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 result = (int) ((arg1)->width);
7726 resultobj = SWIG_From_int(static_cast< int >(result));
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7734 PyObject *resultobj = 0;
7735 wxRect *arg1 = (wxRect *) 0 ;
7736 int arg2 ;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739 int val2 ;
7740 int ecode2 = 0 ;
7741 PyObject *swig_obj[2] ;
7742
7743 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7747 }
7748 arg1 = reinterpret_cast< wxRect * >(argp1);
7749 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7750 if (!SWIG_IsOK(ecode2)) {
7751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7752 }
7753 arg2 = static_cast< int >(val2);
7754 if (arg1) (arg1)->height = arg2;
7755
7756 resultobj = SWIG_Py_Void();
7757 return resultobj;
7758 fail:
7759 return NULL;
7760 }
7761
7762
7763 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7764 PyObject *resultobj = 0;
7765 wxRect *arg1 = (wxRect *) 0 ;
7766 int result;
7767 void *argp1 = 0 ;
7768 int res1 = 0 ;
7769 PyObject *swig_obj[1] ;
7770
7771 if (!args) SWIG_fail;
7772 swig_obj[0] = args;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 result = (int) ((arg1)->height);
7779 resultobj = SWIG_From_int(static_cast< int >(result));
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7787 PyObject *resultobj = 0;
7788 wxRect *arg1 = (wxRect *) 0 ;
7789 int arg2 = (int) 0 ;
7790 int arg3 = (int) 0 ;
7791 int arg4 = (int) 0 ;
7792 int arg5 = (int) 0 ;
7793 void *argp1 = 0 ;
7794 int res1 = 0 ;
7795 int val2 ;
7796 int ecode2 = 0 ;
7797 int val3 ;
7798 int ecode3 = 0 ;
7799 int val4 ;
7800 int ecode4 = 0 ;
7801 int val5 ;
7802 int ecode5 = 0 ;
7803 PyObject * obj0 = 0 ;
7804 PyObject * obj1 = 0 ;
7805 PyObject * obj2 = 0 ;
7806 PyObject * obj3 = 0 ;
7807 PyObject * obj4 = 0 ;
7808 char * kwnames[] = {
7809 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7810 };
7811
7812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7814 if (!SWIG_IsOK(res1)) {
7815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7816 }
7817 arg1 = reinterpret_cast< wxRect * >(argp1);
7818 if (obj1) {
7819 ecode2 = SWIG_AsVal_int(obj1, &val2);
7820 if (!SWIG_IsOK(ecode2)) {
7821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7822 }
7823 arg2 = static_cast< int >(val2);
7824 }
7825 if (obj2) {
7826 ecode3 = SWIG_AsVal_int(obj2, &val3);
7827 if (!SWIG_IsOK(ecode3)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7829 }
7830 arg3 = static_cast< int >(val3);
7831 }
7832 if (obj3) {
7833 ecode4 = SWIG_AsVal_int(obj3, &val4);
7834 if (!SWIG_IsOK(ecode4)) {
7835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7836 }
7837 arg4 = static_cast< int >(val4);
7838 }
7839 if (obj4) {
7840 ecode5 = SWIG_AsVal_int(obj4, &val5);
7841 if (!SWIG_IsOK(ecode5)) {
7842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7843 }
7844 arg5 = static_cast< int >(val5);
7845 }
7846 {
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 resultobj = SWIG_Py_Void();
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7860 PyObject *resultobj = 0;
7861 wxRect *arg1 = (wxRect *) 0 ;
7862 PyObject *result = 0 ;
7863 void *argp1 = 0 ;
7864 int res1 = 0 ;
7865 PyObject *swig_obj[1] ;
7866
7867 if (!args) SWIG_fail;
7868 swig_obj[0] = args;
7869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7870 if (!SWIG_IsOK(res1)) {
7871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7872 }
7873 arg1 = reinterpret_cast< wxRect * >(argp1);
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 result = (PyObject *)wxRect_Get(arg1);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = result;
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7888 PyObject *obj;
7889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7890 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7891 return SWIG_Py_Void();
7892 }
7893
7894 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7895 return SWIG_Python_InitShadowInstance(args);
7896 }
7897
7898 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 wxRect *arg2 = (wxRect *) 0 ;
7902 PyObject *result = 0 ;
7903 void *argp1 = 0 ;
7904 int res1 = 0 ;
7905 void *argp2 = 0 ;
7906 int res2 = 0 ;
7907 PyObject * obj0 = 0 ;
7908 PyObject * obj1 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "r1",(char *) "r2", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7917 }
7918 arg1 = reinterpret_cast< wxRect * >(argp1);
7919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7920 if (!SWIG_IsOK(res2)) {
7921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7922 }
7923 arg2 = reinterpret_cast< wxRect * >(argp2);
7924 {
7925 if (!wxPyCheckForApp()) SWIG_fail;
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 result = (PyObject *)wxIntersectRect(arg1,arg2);
7928 wxPyEndAllowThreads(__tstate);
7929 if (PyErr_Occurred()) SWIG_fail;
7930 }
7931 resultobj = result;
7932 return resultobj;
7933 fail:
7934 return NULL;
7935 }
7936
7937
7938 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7939 PyObject *resultobj = 0;
7940 double arg1 = (double) 0.0 ;
7941 double arg2 = (double) 0.0 ;
7942 wxPoint2D *result = 0 ;
7943 double val1 ;
7944 int ecode1 = 0 ;
7945 double val2 ;
7946 int ecode2 = 0 ;
7947 PyObject * obj0 = 0 ;
7948 PyObject * obj1 = 0 ;
7949 char * kwnames[] = {
7950 (char *) "x",(char *) "y", NULL
7951 };
7952
7953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7954 if (obj0) {
7955 ecode1 = SWIG_AsVal_double(obj0, &val1);
7956 if (!SWIG_IsOK(ecode1)) {
7957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7958 }
7959 arg1 = static_cast< double >(val1);
7960 }
7961 if (obj1) {
7962 ecode2 = SWIG_AsVal_double(obj1, &val2);
7963 if (!SWIG_IsOK(ecode2)) {
7964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7965 }
7966 arg2 = static_cast< double >(val2);
7967 }
7968 {
7969 PyThreadState* __tstate = wxPyBeginAllowThreads();
7970 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7975 return resultobj;
7976 fail:
7977 return NULL;
7978 }
7979
7980
7981 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7982 PyObject *resultobj = 0;
7983 wxPoint2D *arg1 = 0 ;
7984 wxPoint2D *result = 0 ;
7985 wxPoint2D temp1 ;
7986 PyObject * obj0 = 0 ;
7987 char * kwnames[] = {
7988 (char *) "pt", NULL
7989 };
7990
7991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7992 {
7993 arg1 = &temp1;
7994 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7995 }
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxPoint *arg1 = 0 ;
8012 wxPoint2D *result = 0 ;
8013 wxPoint temp1 ;
8014 PyObject * obj0 = 0 ;
8015 char * kwnames[] = {
8016 (char *) "pt", NULL
8017 };
8018
8019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8020 {
8021 arg1 = &temp1;
8022 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8023 }
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8040 int *arg2 = (int *) 0 ;
8041 int *arg3 = (int *) 0 ;
8042 void *argp1 = 0 ;
8043 int res1 = 0 ;
8044 int temp2 ;
8045 int res2 = SWIG_TMPOBJ ;
8046 int temp3 ;
8047 int res3 = SWIG_TMPOBJ ;
8048 PyObject *swig_obj[1] ;
8049
8050 arg2 = &temp2;
8051 arg3 = &temp3;
8052 if (!args) SWIG_fail;
8053 swig_obj[0] = args;
8054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8057 }
8058 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = SWIG_Py_Void();
8066 if (SWIG_IsTmpObj(res2)) {
8067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8068 } else {
8069 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8071 }
8072 if (SWIG_IsTmpObj(res3)) {
8073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8074 } else {
8075 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8077 }
8078 return resultobj;
8079 fail:
8080 return NULL;
8081 }
8082
8083
8084 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8085 PyObject *resultobj = 0;
8086 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8087 int *arg2 = (int *) 0 ;
8088 int *arg3 = (int *) 0 ;
8089 void *argp1 = 0 ;
8090 int res1 = 0 ;
8091 int temp2 ;
8092 int res2 = SWIG_TMPOBJ ;
8093 int temp3 ;
8094 int res3 = SWIG_TMPOBJ ;
8095 PyObject *swig_obj[1] ;
8096
8097 arg2 = &temp2;
8098 arg3 = &temp3;
8099 if (!args) SWIG_fail;
8100 swig_obj[0] = args;
8101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8104 }
8105 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 resultobj = SWIG_Py_Void();
8113 if (SWIG_IsTmpObj(res2)) {
8114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8115 } else {
8116 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8118 }
8119 if (SWIG_IsTmpObj(res3)) {
8120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8121 } else {
8122 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8124 }
8125 return resultobj;
8126 fail:
8127 return NULL;
8128 }
8129
8130
8131 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8132 PyObject *resultobj = 0;
8133 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8134 double result;
8135 void *argp1 = 0 ;
8136 int res1 = 0 ;
8137 PyObject *swig_obj[1] ;
8138
8139 if (!args) SWIG_fail;
8140 swig_obj[0] = args;
8141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8144 }
8145 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8146 {
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 resultobj = SWIG_From_double(static_cast< double >(result));
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8162 double result;
8163 void *argp1 = 0 ;
8164 int res1 = 0 ;
8165 PyObject *swig_obj[1] ;
8166
8167 if (!args) SWIG_fail;
8168 swig_obj[0] = args;
8169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8170 if (!SWIG_IsOK(res1)) {
8171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8172 }
8173 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8174 {
8175 PyThreadState* __tstate = wxPyBeginAllowThreads();
8176 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 resultobj = SWIG_From_double(static_cast< double >(result));
8181 return resultobj;
8182 fail:
8183 return NULL;
8184 }
8185
8186
8187 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8188 PyObject *resultobj = 0;
8189 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8190 double arg2 ;
8191 void *argp1 = 0 ;
8192 int res1 = 0 ;
8193 double val2 ;
8194 int ecode2 = 0 ;
8195 PyObject * obj0 = 0 ;
8196 PyObject * obj1 = 0 ;
8197 char * kwnames[] = {
8198 (char *) "self",(char *) "length", NULL
8199 };
8200
8201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8203 if (!SWIG_IsOK(res1)) {
8204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8205 }
8206 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8207 ecode2 = SWIG_AsVal_double(obj1, &val2);
8208 if (!SWIG_IsOK(ecode2)) {
8209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8210 }
8211 arg2 = static_cast< double >(val2);
8212 {
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 (arg1)->SetVectorLength(arg2);
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 resultobj = SWIG_Py_Void();
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj = 0;
8227 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8228 double arg2 ;
8229 void *argp1 = 0 ;
8230 int res1 = 0 ;
8231 double val2 ;
8232 int ecode2 = 0 ;
8233 PyObject * obj0 = 0 ;
8234 PyObject * obj1 = 0 ;
8235 char * kwnames[] = {
8236 (char *) "self",(char *) "degrees", NULL
8237 };
8238
8239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8241 if (!SWIG_IsOK(res1)) {
8242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8243 }
8244 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8245 ecode2 = SWIG_AsVal_double(obj1, &val2);
8246 if (!SWIG_IsOK(ecode2)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8248 }
8249 arg2 = static_cast< double >(val2);
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 (arg1)->SetVectorAngle(arg2);
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_Py_Void();
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8266 wxPoint2D *arg2 = 0 ;
8267 double result;
8268 void *argp1 = 0 ;
8269 int res1 = 0 ;
8270 wxPoint2D temp2 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 char * kwnames[] = {
8274 (char *) "self",(char *) "pt", NULL
8275 };
8276
8277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8281 }
8282 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8283 {
8284 arg2 = &temp2;
8285 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8286 }
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_From_double(static_cast< double >(result));
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 wxPoint2D *arg2 = 0 ;
8304 double result;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 wxPoint2D temp2 ;
8308 PyObject * obj0 = 0 ;
8309 PyObject * obj1 = 0 ;
8310 char * kwnames[] = {
8311 (char *) "self",(char *) "pt", NULL
8312 };
8313
8314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8316 if (!SWIG_IsOK(res1)) {
8317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8318 }
8319 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8320 {
8321 arg2 = &temp2;
8322 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8327 wxPyEndAllowThreads(__tstate);
8328 if (PyErr_Occurred()) SWIG_fail;
8329 }
8330 resultobj = SWIG_From_double(static_cast< double >(result));
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj = 0;
8339 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8340 wxPoint2D *arg2 = 0 ;
8341 double result;
8342 void *argp1 = 0 ;
8343 int res1 = 0 ;
8344 wxPoint2D temp2 ;
8345 PyObject * obj0 = 0 ;
8346 PyObject * obj1 = 0 ;
8347 char * kwnames[] = {
8348 (char *) "self",(char *) "vec", NULL
8349 };
8350
8351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8353 if (!SWIG_IsOK(res1)) {
8354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8355 }
8356 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8357 {
8358 arg2 = &temp2;
8359 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8360 }
8361 {
8362 PyThreadState* __tstate = wxPyBeginAllowThreads();
8363 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8364 wxPyEndAllowThreads(__tstate);
8365 if (PyErr_Occurred()) SWIG_fail;
8366 }
8367 resultobj = SWIG_From_double(static_cast< double >(result));
8368 return resultobj;
8369 fail:
8370 return NULL;
8371 }
8372
8373
8374 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8375 PyObject *resultobj = 0;
8376 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8377 wxPoint2D *arg2 = 0 ;
8378 double result;
8379 void *argp1 = 0 ;
8380 int res1 = 0 ;
8381 wxPoint2D temp2 ;
8382 PyObject * obj0 = 0 ;
8383 PyObject * obj1 = 0 ;
8384 char * kwnames[] = {
8385 (char *) "self",(char *) "vec", NULL
8386 };
8387
8388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8390 if (!SWIG_IsOK(res1)) {
8391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8392 }
8393 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8394 {
8395 arg2 = &temp2;
8396 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8397 }
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 resultobj = SWIG_From_double(static_cast< double >(result));
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412 PyObject *resultobj = 0;
8413 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8414 wxPoint2D result;
8415 void *argp1 = 0 ;
8416 int res1 = 0 ;
8417 PyObject *swig_obj[1] ;
8418
8419 if (!args) SWIG_fail;
8420 swig_obj[0] = args;
8421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8422 if (!SWIG_IsOK(res1)) {
8423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8424 }
8425 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (arg1)->operator -();
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8440 PyObject *resultobj = 0;
8441 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8442 wxPoint2D *arg2 = 0 ;
8443 wxPoint2D *result = 0 ;
8444 void *argp1 = 0 ;
8445 int res1 = 0 ;
8446 wxPoint2D temp2 ;
8447 PyObject * obj0 = 0 ;
8448 PyObject * obj1 = 0 ;
8449 char * kwnames[] = {
8450 (char *) "self",(char *) "pt", NULL
8451 };
8452
8453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8455 if (!SWIG_IsOK(res1)) {
8456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8457 }
8458 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8459 {
8460 arg2 = &temp2;
8461 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8462 }
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 {
8466 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8467 result = (wxPoint2D *) &_result_ref;
8468 }
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8480 PyObject *resultobj = 0;
8481 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8482 wxPoint2D *arg2 = 0 ;
8483 wxPoint2D *result = 0 ;
8484 void *argp1 = 0 ;
8485 int res1 = 0 ;
8486 wxPoint2D temp2 ;
8487 PyObject * obj0 = 0 ;
8488 PyObject * obj1 = 0 ;
8489 char * kwnames[] = {
8490 (char *) "self",(char *) "pt", NULL
8491 };
8492
8493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8495 if (!SWIG_IsOK(res1)) {
8496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8497 }
8498 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8499 {
8500 arg2 = &temp2;
8501 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8502 }
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 {
8506 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8507 result = (wxPoint2D *) &_result_ref;
8508 }
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj = 0;
8521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8522 wxPoint2D *arg2 = 0 ;
8523 wxPoint2D *result = 0 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 wxPoint2D temp2 ;
8527 PyObject * obj0 = 0 ;
8528 PyObject * obj1 = 0 ;
8529 char * kwnames[] = {
8530 (char *) "self",(char *) "pt", NULL
8531 };
8532
8533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8535 if (!SWIG_IsOK(res1)) {
8536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8537 }
8538 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8539 {
8540 arg2 = &temp2;
8541 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8542 }
8543 {
8544 PyThreadState* __tstate = wxPyBeginAllowThreads();
8545 {
8546 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8547 result = (wxPoint2D *) &_result_ref;
8548 }
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj = 0;
8561 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8562 wxPoint2D *arg2 = 0 ;
8563 wxPoint2D *result = 0 ;
8564 void *argp1 = 0 ;
8565 int res1 = 0 ;
8566 wxPoint2D temp2 ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char * kwnames[] = {
8570 (char *) "self",(char *) "pt", NULL
8571 };
8572
8573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8577 }
8578 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8579 {
8580 arg2 = &temp2;
8581 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8582 }
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 {
8586 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8587 result = (wxPoint2D *) &_result_ref;
8588 }
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 PyObject *arg2 = (PyObject *) 0 ;
8603 bool result;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "other", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 arg2 = obj1;
8619 {
8620 result = (bool)wxPoint2D___eq__(arg1,arg2);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 {
8624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8625 }
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj = 0;
8634 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8635 PyObject *arg2 = (PyObject *) 0 ;
8636 bool result;
8637 void *argp1 = 0 ;
8638 int res1 = 0 ;
8639 PyObject * obj0 = 0 ;
8640 PyObject * obj1 = 0 ;
8641 char * kwnames[] = {
8642 (char *) "self",(char *) "other", NULL
8643 };
8644
8645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8647 if (!SWIG_IsOK(res1)) {
8648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8649 }
8650 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8651 arg2 = obj1;
8652 {
8653 result = (bool)wxPoint2D___ne__(arg1,arg2);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 {
8657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8658 }
8659 return resultobj;
8660 fail:
8661 return NULL;
8662 }
8663
8664
8665 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8666 PyObject *resultobj = 0;
8667 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8668 double arg2 ;
8669 void *argp1 = 0 ;
8670 int res1 = 0 ;
8671 double val2 ;
8672 int ecode2 = 0 ;
8673 PyObject *swig_obj[2] ;
8674
8675 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8682 if (!SWIG_IsOK(ecode2)) {
8683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8684 }
8685 arg2 = static_cast< double >(val2);
8686 if (arg1) (arg1)->m_x = arg2;
8687
8688 resultobj = SWIG_Py_Void();
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696 PyObject *resultobj = 0;
8697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8698 double 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_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8708 }
8709 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8710 result = (double) ((arg1)->m_x);
8711 resultobj = SWIG_From_double(static_cast< double >(result));
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8719 PyObject *resultobj = 0;
8720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8721 double arg2 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 double val2 ;
8725 int ecode2 = 0 ;
8726 PyObject *swig_obj[2] ;
8727
8728 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8730 if (!SWIG_IsOK(res1)) {
8731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8732 }
8733 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8734 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8735 if (!SWIG_IsOK(ecode2)) {
8736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8737 }
8738 arg2 = static_cast< double >(val2);
8739 if (arg1) (arg1)->m_y = arg2;
8740
8741 resultobj = SWIG_Py_Void();
8742 return resultobj;
8743 fail:
8744 return NULL;
8745 }
8746
8747
8748 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8749 PyObject *resultobj = 0;
8750 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8751 double result;
8752 void *argp1 = 0 ;
8753 int res1 = 0 ;
8754 PyObject *swig_obj[1] ;
8755
8756 if (!args) SWIG_fail;
8757 swig_obj[0] = args;
8758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8759 if (!SWIG_IsOK(res1)) {
8760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8761 }
8762 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8763 result = (double) ((arg1)->m_y);
8764 resultobj = SWIG_From_double(static_cast< double >(result));
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 double arg2 = (double) 0 ;
8775 double arg3 = (double) 0 ;
8776 void *argp1 = 0 ;
8777 int res1 = 0 ;
8778 double val2 ;
8779 int ecode2 = 0 ;
8780 double val3 ;
8781 int ecode3 = 0 ;
8782 PyObject * obj0 = 0 ;
8783 PyObject * obj1 = 0 ;
8784 PyObject * obj2 = 0 ;
8785 char * kwnames[] = {
8786 (char *) "self",(char *) "x",(char *) "y", NULL
8787 };
8788
8789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8791 if (!SWIG_IsOK(res1)) {
8792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8793 }
8794 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8795 if (obj1) {
8796 ecode2 = SWIG_AsVal_double(obj1, &val2);
8797 if (!SWIG_IsOK(ecode2)) {
8798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8799 }
8800 arg2 = static_cast< double >(val2);
8801 }
8802 if (obj2) {
8803 ecode3 = SWIG_AsVal_double(obj2, &val3);
8804 if (!SWIG_IsOK(ecode3)) {
8805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8806 }
8807 arg3 = static_cast< double >(val3);
8808 }
8809 {
8810 PyThreadState* __tstate = wxPyBeginAllowThreads();
8811 wxPoint2D_Set(arg1,arg2,arg3);
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 resultobj = SWIG_Py_Void();
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8823 PyObject *resultobj = 0;
8824 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8825 PyObject *result = 0 ;
8826 void *argp1 = 0 ;
8827 int res1 = 0 ;
8828 PyObject *swig_obj[1] ;
8829
8830 if (!args) SWIG_fail;
8831 swig_obj[0] = args;
8832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8833 if (!SWIG_IsOK(res1)) {
8834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8835 }
8836 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 result = (PyObject *)wxPoint2D_Get(arg1);
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = result;
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8851 PyObject *obj;
8852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8853 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8854 return SWIG_Py_Void();
8855 }
8856
8857 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8858 return SWIG_Python_InitShadowInstance(args);
8859 }
8860
8861 SWIGINTERN int DefaultPosition_set(PyObject *) {
8862 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8863 return 1;
8864 }
8865
8866
8867 SWIGINTERN PyObject *DefaultPosition_get(void) {
8868 PyObject *pyobj = 0;
8869
8870 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8871 return pyobj;
8872 }
8873
8874
8875 SWIGINTERN int DefaultSize_set(PyObject *) {
8876 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8877 return 1;
8878 }
8879
8880
8881 SWIGINTERN PyObject *DefaultSize_get(void) {
8882 PyObject *pyobj = 0;
8883
8884 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8885 return pyobj;
8886 }
8887
8888
8889 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8890 PyObject *resultobj = 0;
8891 PyObject *arg1 = (PyObject *) 0 ;
8892 wxPyInputStream *result = 0 ;
8893 PyObject * obj0 = 0 ;
8894 char * kwnames[] = {
8895 (char *) "p", NULL
8896 };
8897
8898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8899 arg1 = obj0;
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8914 PyObject *resultobj = 0;
8915 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8916 void *argp1 = 0 ;
8917 int res1 = 0 ;
8918 PyObject *swig_obj[1] ;
8919
8920 if (!args) SWIG_fail;
8921 swig_obj[0] = args;
8922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8923 if (!SWIG_IsOK(res1)) {
8924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8925 }
8926 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 delete arg1;
8930
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_Py_Void();
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 PyObject *swig_obj[1] ;
8947
8948 if (!args) SWIG_fail;
8949 swig_obj[0] = args;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 (arg1)->close();
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *resultobj = 0;
8970 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 PyObject *swig_obj[1] ;
8974
8975 if (!args) SWIG_fail;
8976 swig_obj[0] = args;
8977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8978 if (!SWIG_IsOK(res1)) {
8979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8980 }
8981 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 (arg1)->flush();
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 resultobj = SWIG_Py_Void();
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8998 bool result;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 PyObject *swig_obj[1] ;
9002
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9006 if (!SWIG_IsOK(res1)) {
9007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9008 }
9009 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 result = (bool)(arg1)->eof();
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 {
9017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9018 }
9019 return resultobj;
9020 fail:
9021 return NULL;
9022 }
9023
9024
9025 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9026 PyObject *resultobj = 0;
9027 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9028 int arg2 = (int) -1 ;
9029 PyObject *result = 0 ;
9030 void *argp1 = 0 ;
9031 int res1 = 0 ;
9032 int val2 ;
9033 int ecode2 = 0 ;
9034 PyObject * obj0 = 0 ;
9035 PyObject * obj1 = 0 ;
9036 char * kwnames[] = {
9037 (char *) "self",(char *) "size", NULL
9038 };
9039
9040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9044 }
9045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9046 if (obj1) {
9047 ecode2 = SWIG_AsVal_int(obj1, &val2);
9048 if (!SWIG_IsOK(ecode2)) {
9049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9050 }
9051 arg2 = static_cast< int >(val2);
9052 }
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = (PyObject *)(arg1)->read(arg2);
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = result;
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9067 PyObject *resultobj = 0;
9068 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9069 int arg2 = (int) -1 ;
9070 PyObject *result = 0 ;
9071 void *argp1 = 0 ;
9072 int res1 = 0 ;
9073 int val2 ;
9074 int ecode2 = 0 ;
9075 PyObject * obj0 = 0 ;
9076 PyObject * obj1 = 0 ;
9077 char * kwnames[] = {
9078 (char *) "self",(char *) "size", NULL
9079 };
9080
9081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9085 }
9086 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9087 if (obj1) {
9088 ecode2 = SWIG_AsVal_int(obj1, &val2);
9089 if (!SWIG_IsOK(ecode2)) {
9090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9091 }
9092 arg2 = static_cast< int >(val2);
9093 }
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 result = (PyObject *)(arg1)->readline(arg2);
9097 wxPyEndAllowThreads(__tstate);
9098 if (PyErr_Occurred()) SWIG_fail;
9099 }
9100 resultobj = result;
9101 return resultobj;
9102 fail:
9103 return NULL;
9104 }
9105
9106
9107 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9108 PyObject *resultobj = 0;
9109 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9110 int arg2 = (int) -1 ;
9111 PyObject *result = 0 ;
9112 void *argp1 = 0 ;
9113 int res1 = 0 ;
9114 int val2 ;
9115 int ecode2 = 0 ;
9116 PyObject * obj0 = 0 ;
9117 PyObject * obj1 = 0 ;
9118 char * kwnames[] = {
9119 (char *) "self",(char *) "sizehint", NULL
9120 };
9121
9122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9124 if (!SWIG_IsOK(res1)) {
9125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9126 }
9127 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9128 if (obj1) {
9129 ecode2 = SWIG_AsVal_int(obj1, &val2);
9130 if (!SWIG_IsOK(ecode2)) {
9131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9132 }
9133 arg2 = static_cast< int >(val2);
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 result = (PyObject *)(arg1)->readlines(arg2);
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 resultobj = result;
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj = 0;
9150 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9151 int arg2 ;
9152 int arg3 = (int) 0 ;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 int val2 ;
9156 int ecode2 = 0 ;
9157 int val3 ;
9158 int ecode3 = 0 ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 PyObject * obj2 = 0 ;
9162 char * kwnames[] = {
9163 (char *) "self",(char *) "offset",(char *) "whence", NULL
9164 };
9165
9166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9168 if (!SWIG_IsOK(res1)) {
9169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9170 }
9171 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9172 ecode2 = SWIG_AsVal_int(obj1, &val2);
9173 if (!SWIG_IsOK(ecode2)) {
9174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9175 }
9176 arg2 = static_cast< int >(val2);
9177 if (obj2) {
9178 ecode3 = SWIG_AsVal_int(obj2, &val3);
9179 if (!SWIG_IsOK(ecode3)) {
9180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9181 }
9182 arg3 = static_cast< int >(val3);
9183 }
9184 {
9185 PyThreadState* __tstate = wxPyBeginAllowThreads();
9186 (arg1)->seek(arg2,arg3);
9187 wxPyEndAllowThreads(__tstate);
9188 if (PyErr_Occurred()) SWIG_fail;
9189 }
9190 resultobj = SWIG_Py_Void();
9191 return resultobj;
9192 fail:
9193 return NULL;
9194 }
9195
9196
9197 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9198 PyObject *resultobj = 0;
9199 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9200 int result;
9201 void *argp1 = 0 ;
9202 int res1 = 0 ;
9203 PyObject *swig_obj[1] ;
9204
9205 if (!args) SWIG_fail;
9206 swig_obj[0] = args;
9207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9208 if (!SWIG_IsOK(res1)) {
9209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9210 }
9211 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (int)(arg1)->tell();
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = SWIG_From_int(static_cast< int >(result));
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9228 char result;
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_wxPyInputStream, 0 | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9238 }
9239 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = (char)(arg1)->Peek();
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_From_char(static_cast< char >(result));
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9256 char result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9266 }
9267 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 result = (char)(arg1)->GetC();
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 resultobj = SWIG_From_char(static_cast< char >(result));
9275 return resultobj;
9276 fail:
9277 return NULL;
9278 }
9279
9280
9281 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9282 PyObject *resultobj = 0;
9283 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9284 size_t result;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9294 }
9295 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 result = (size_t)(arg1)->LastRead();
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9310 PyObject *resultobj = 0;
9311 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9312 bool result;
9313 void *argp1 = 0 ;
9314 int res1 = 0 ;
9315 PyObject *swig_obj[1] ;
9316
9317 if (!args) SWIG_fail;
9318 swig_obj[0] = args;
9319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9322 }
9323 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (bool)(arg1)->CanRead();
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 {
9331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9332 }
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9342 bool result;
9343 void *argp1 = 0 ;
9344 int res1 = 0 ;
9345 PyObject *swig_obj[1] ;
9346
9347 if (!args) SWIG_fail;
9348 swig_obj[0] = args;
9349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9350 if (!SWIG_IsOK(res1)) {
9351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9352 }
9353 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9354 {
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (bool)(arg1)->Eof();
9357 wxPyEndAllowThreads(__tstate);
9358 if (PyErr_Occurred()) SWIG_fail;
9359 }
9360 {
9361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9362 }
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = 0;
9371 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9372 char arg2 ;
9373 bool result;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 char val2 ;
9377 int ecode2 = 0 ;
9378 PyObject * obj0 = 0 ;
9379 PyObject * obj1 = 0 ;
9380 char * kwnames[] = {
9381 (char *) "self",(char *) "c", NULL
9382 };
9383
9384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9386 if (!SWIG_IsOK(res1)) {
9387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9388 }
9389 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9390 ecode2 = SWIG_AsVal_char(obj1, &val2);
9391 if (!SWIG_IsOK(ecode2)) {
9392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9393 }
9394 arg2 = static_cast< char >(val2);
9395 {
9396 PyThreadState* __tstate = wxPyBeginAllowThreads();
9397 result = (bool)(arg1)->Ungetch(arg2);
9398 wxPyEndAllowThreads(__tstate);
9399 if (PyErr_Occurred()) SWIG_fail;
9400 }
9401 {
9402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9403 }
9404 return resultobj;
9405 fail:
9406 return NULL;
9407 }
9408
9409
9410 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj = 0;
9412 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9413 long arg2 ;
9414 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9415 long result;
9416 void *argp1 = 0 ;
9417 int res1 = 0 ;
9418 long val2 ;
9419 int ecode2 = 0 ;
9420 int val3 ;
9421 int ecode3 = 0 ;
9422 PyObject * obj0 = 0 ;
9423 PyObject * obj1 = 0 ;
9424 PyObject * obj2 = 0 ;
9425 char * kwnames[] = {
9426 (char *) "self",(char *) "pos",(char *) "mode", NULL
9427 };
9428
9429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9431 if (!SWIG_IsOK(res1)) {
9432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9433 }
9434 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9435 ecode2 = SWIG_AsVal_long(obj1, &val2);
9436 if (!SWIG_IsOK(ecode2)) {
9437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9438 }
9439 arg2 = static_cast< long >(val2);
9440 if (obj2) {
9441 ecode3 = SWIG_AsVal_int(obj2, &val3);
9442 if (!SWIG_IsOK(ecode3)) {
9443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9444 }
9445 arg3 = static_cast< wxSeekMode >(val3);
9446 }
9447 {
9448 PyThreadState* __tstate = wxPyBeginAllowThreads();
9449 result = (long)(arg1)->SeekI(arg2,arg3);
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 resultobj = SWIG_From_long(static_cast< long >(result));
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461 PyObject *resultobj = 0;
9462 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9463 long result;
9464 void *argp1 = 0 ;
9465 int res1 = 0 ;
9466 PyObject *swig_obj[1] ;
9467
9468 if (!args) SWIG_fail;
9469 swig_obj[0] = args;
9470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9471 if (!SWIG_IsOK(res1)) {
9472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9473 }
9474 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (long)(arg1)->TellI();
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_From_long(static_cast< long >(result));
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *obj;
9490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9491 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9492 return SWIG_Py_Void();
9493 }
9494
9495 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9496 return SWIG_Python_InitShadowInstance(args);
9497 }
9498
9499 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9500 PyObject *resultobj = 0;
9501 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9502 PyObject *arg2 = (PyObject *) 0 ;
9503 void *argp1 = 0 ;
9504 int res1 = 0 ;
9505 PyObject * obj0 = 0 ;
9506 PyObject * obj1 = 0 ;
9507 char * kwnames[] = {
9508 (char *) "self",(char *) "obj", NULL
9509 };
9510
9511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9513 if (!SWIG_IsOK(res1)) {
9514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9515 }
9516 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9517 arg2 = obj1;
9518 {
9519 PyThreadState* __tstate = wxPyBeginAllowThreads();
9520 wxOutputStream_write(arg1,arg2);
9521 wxPyEndAllowThreads(__tstate);
9522 if (PyErr_Occurred()) SWIG_fail;
9523 }
9524 resultobj = SWIG_Py_Void();
9525 return resultobj;
9526 fail:
9527 return NULL;
9528 }
9529
9530
9531 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9532 PyObject *resultobj = 0;
9533 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9534 size_t result;
9535 void *argp1 = 0 ;
9536 int res1 = 0 ;
9537 PyObject *swig_obj[1] ;
9538
9539 if (!args) SWIG_fail;
9540 swig_obj[0] = args;
9541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9544 }
9545 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9560 PyObject *obj;
9561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9562 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9563 return SWIG_Py_Void();
9564 }
9565
9566 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj = 0;
9568 wxInputStream *arg1 = (wxInputStream *) 0 ;
9569 wxString *arg2 = 0 ;
9570 wxString *arg3 = 0 ;
9571 wxString *arg4 = 0 ;
9572 wxDateTime arg5 ;
9573 wxFSFile *result = 0 ;
9574 wxPyInputStream *temp1 ;
9575 bool temp2 = false ;
9576 bool temp3 = false ;
9577 bool temp4 = false ;
9578 void *argp5 ;
9579 int res5 = 0 ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 PyObject * obj2 = 0 ;
9583 PyObject * obj3 = 0 ;
9584 PyObject * obj4 = 0 ;
9585 char * kwnames[] = {
9586 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9587 };
9588
9589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9590 {
9591 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9592 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9593 } else {
9594 PyErr_Clear(); // clear the failure of the wxPyConvert above
9595 arg1 = wxPyCBInputStream_create(obj0, true);
9596 if (arg1 == NULL) {
9597 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9598 SWIG_fail;
9599 }
9600 }
9601 }
9602 {
9603 arg2 = wxString_in_helper(obj1);
9604 if (arg2 == NULL) SWIG_fail;
9605 temp2 = true;
9606 }
9607 {
9608 arg3 = wxString_in_helper(obj2);
9609 if (arg3 == NULL) SWIG_fail;
9610 temp3 = true;
9611 }
9612 {
9613 arg4 = wxString_in_helper(obj3);
9614 if (arg4 == NULL) SWIG_fail;
9615 temp4 = true;
9616 }
9617 {
9618 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9619 if (!SWIG_IsOK(res5)) {
9620 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9621 }
9622 if (!argp5) {
9623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9624 } else {
9625 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9626 arg5 = *temp;
9627 if (SWIG_IsNewObj(res5)) delete temp;
9628 }
9629 }
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 {
9637 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9638 }
9639 {
9640 if (temp2)
9641 delete arg2;
9642 }
9643 {
9644 if (temp3)
9645 delete arg3;
9646 }
9647 {
9648 if (temp4)
9649 delete arg4;
9650 }
9651 return resultobj;
9652 fail:
9653 {
9654 if (temp2)
9655 delete arg2;
9656 }
9657 {
9658 if (temp3)
9659 delete arg3;
9660 }
9661 {
9662 if (temp4)
9663 delete arg4;
9664 }
9665 return NULL;
9666 }
9667
9668
9669 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9670 PyObject *resultobj = 0;
9671 wxFSFile *arg1 = (wxFSFile *) 0 ;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 PyObject *swig_obj[1] ;
9675
9676 if (!args) SWIG_fail;
9677 swig_obj[0] = args;
9678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9681 }
9682 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 delete arg1;
9686
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9698 PyObject *resultobj = 0;
9699 wxFSFile *arg1 = (wxFSFile *) 0 ;
9700 wxInputStream *result = 0 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 PyObject *swig_obj[1] ;
9704
9705 if (!args) SWIG_fail;
9706 swig_obj[0] = args;
9707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9708 if (!SWIG_IsOK(res1)) {
9709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9710 }
9711 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 result = (wxInputStream *)(arg1)->GetStream();
9715 wxPyEndAllowThreads(__tstate);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 {
9719 wxPyInputStream * _ptr = NULL;
9720
9721 if (result) {
9722 _ptr = new wxPyInputStream(result);
9723 }
9724 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9725 }
9726 return resultobj;
9727 fail:
9728 return NULL;
9729 }
9730
9731
9732 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9733 PyObject *resultobj = 0;
9734 wxFSFile *arg1 = (wxFSFile *) 0 ;
9735 wxString *result = 0 ;
9736 void *argp1 = 0 ;
9737 int res1 = 0 ;
9738 PyObject *swig_obj[1] ;
9739
9740 if (!args) SWIG_fail;
9741 swig_obj[0] = args;
9742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9743 if (!SWIG_IsOK(res1)) {
9744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9745 }
9746 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 {
9750 wxString const &_result_ref = (arg1)->GetMimeType();
9751 result = (wxString *) &_result_ref;
9752 }
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 {
9757 #if wxUSE_UNICODE
9758 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9759 #else
9760 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9761 #endif
9762 }
9763 return resultobj;
9764 fail:
9765 return NULL;
9766 }
9767
9768
9769 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9770 PyObject *resultobj = 0;
9771 wxFSFile *arg1 = (wxFSFile *) 0 ;
9772 wxString *result = 0 ;
9773 void *argp1 = 0 ;
9774 int res1 = 0 ;
9775 PyObject *swig_obj[1] ;
9776
9777 if (!args) SWIG_fail;
9778 swig_obj[0] = args;
9779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9780 if (!SWIG_IsOK(res1)) {
9781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9782 }
9783 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 {
9787 wxString const &_result_ref = (arg1)->GetLocation();
9788 result = (wxString *) &_result_ref;
9789 }
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 {
9794 #if wxUSE_UNICODE
9795 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9796 #else
9797 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9798 #endif
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 wxFSFile *arg1 = (wxFSFile *) 0 ;
9809 wxString *result = 0 ;
9810 void *argp1 = 0 ;
9811 int res1 = 0 ;
9812 PyObject *swig_obj[1] ;
9813
9814 if (!args) SWIG_fail;
9815 swig_obj[0] = args;
9816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9819 }
9820 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9821 {
9822 PyThreadState* __tstate = wxPyBeginAllowThreads();
9823 {
9824 wxString const &_result_ref = (arg1)->GetAnchor();
9825 result = (wxString *) &_result_ref;
9826 }
9827 wxPyEndAllowThreads(__tstate);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 {
9831 #if wxUSE_UNICODE
9832 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9833 #else
9834 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9835 #endif
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9844 PyObject *resultobj = 0;
9845 wxFSFile *arg1 = (wxFSFile *) 0 ;
9846 wxDateTime result;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 PyObject *swig_obj[1] ;
9850
9851 if (!args) SWIG_fail;
9852 swig_obj[0] = args;
9853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9854 if (!SWIG_IsOK(res1)) {
9855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9856 }
9857 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 result = (arg1)->GetModificationTime();
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872 PyObject *obj;
9873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9874 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9875 return SWIG_Py_Void();
9876 }
9877
9878 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9879 return SWIG_Python_InitShadowInstance(args);
9880 }
9881
9882 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 PyObject *resultobj = 0;
9884 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 PyObject *swig_obj[1] ;
9888
9889 if (!args) SWIG_fail;
9890 swig_obj[0] = args;
9891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9894 }
9895 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 delete arg1;
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 resultobj = SWIG_Py_Void();
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9911 PyObject *obj;
9912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9913 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9914 return SWIG_Py_Void();
9915 }
9916
9917 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxPyFileSystemHandler *result = 0 ;
9920
9921 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj = 0;
9937 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9938 PyObject *arg2 = (PyObject *) 0 ;
9939 PyObject *arg3 = (PyObject *) 0 ;
9940 void *argp1 = 0 ;
9941 int res1 = 0 ;
9942 PyObject * obj0 = 0 ;
9943 PyObject * obj1 = 0 ;
9944 PyObject * obj2 = 0 ;
9945 char * kwnames[] = {
9946 (char *) "self",(char *) "self",(char *) "_class", NULL
9947 };
9948
9949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9953 }
9954 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9955 arg2 = obj1;
9956 arg3 = obj2;
9957 {
9958 PyThreadState* __tstate = wxPyBeginAllowThreads();
9959 (arg1)->_setCallbackInfo(arg2,arg3);
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 resultobj = SWIG_Py_Void();
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj = 0;
9972 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9973 wxString *arg2 = 0 ;
9974 bool result;
9975 void *argp1 = 0 ;
9976 int res1 = 0 ;
9977 bool temp2 = false ;
9978 PyObject * obj0 = 0 ;
9979 PyObject * obj1 = 0 ;
9980 char * kwnames[] = {
9981 (char *) "self",(char *) "location", NULL
9982 };
9983
9984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9988 }
9989 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9990 {
9991 arg2 = wxString_in_helper(obj1);
9992 if (arg2 == NULL) SWIG_fail;
9993 temp2 = true;
9994 }
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 {
10002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10003 }
10004 {
10005 if (temp2)
10006 delete arg2;
10007 }
10008 return resultobj;
10009 fail:
10010 {
10011 if (temp2)
10012 delete arg2;
10013 }
10014 return NULL;
10015 }
10016
10017
10018 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10019 PyObject *resultobj = 0;
10020 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10021 wxFileSystem *arg2 = 0 ;
10022 wxString *arg3 = 0 ;
10023 wxFSFile *result = 0 ;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 void *argp2 = 0 ;
10027 int res2 = 0 ;
10028 bool temp3 = false ;
10029 PyObject * obj0 = 0 ;
10030 PyObject * obj1 = 0 ;
10031 PyObject * obj2 = 0 ;
10032 char * kwnames[] = {
10033 (char *) "self",(char *) "fs",(char *) "location", NULL
10034 };
10035
10036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10040 }
10041 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10043 if (!SWIG_IsOK(res2)) {
10044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10045 }
10046 if (!argp2) {
10047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10048 }
10049 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10050 {
10051 arg3 = wxString_in_helper(obj2);
10052 if (arg3 == NULL) SWIG_fail;
10053 temp3 = true;
10054 }
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 {
10062 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10063 }
10064 {
10065 if (temp3)
10066 delete arg3;
10067 }
10068 return resultobj;
10069 fail:
10070 {
10071 if (temp3)
10072 delete arg3;
10073 }
10074 return NULL;
10075 }
10076
10077
10078 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10079 PyObject *resultobj = 0;
10080 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10081 wxString *arg2 = 0 ;
10082 int arg3 = (int) 0 ;
10083 wxString result;
10084 void *argp1 = 0 ;
10085 int res1 = 0 ;
10086 bool temp2 = false ;
10087 int val3 ;
10088 int ecode3 = 0 ;
10089 PyObject * obj0 = 0 ;
10090 PyObject * obj1 = 0 ;
10091 PyObject * obj2 = 0 ;
10092 char * kwnames[] = {
10093 (char *) "self",(char *) "spec",(char *) "flags", NULL
10094 };
10095
10096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10098 if (!SWIG_IsOK(res1)) {
10099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10100 }
10101 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10102 {
10103 arg2 = wxString_in_helper(obj1);
10104 if (arg2 == NULL) SWIG_fail;
10105 temp2 = true;
10106 }
10107 if (obj2) {
10108 ecode3 = SWIG_AsVal_int(obj2, &val3);
10109 if (!SWIG_IsOK(ecode3)) {
10110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10111 }
10112 arg3 = static_cast< int >(val3);
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 {
10121 #if wxUSE_UNICODE
10122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10123 #else
10124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10125 #endif
10126 }
10127 {
10128 if (temp2)
10129 delete arg2;
10130 }
10131 return resultobj;
10132 fail:
10133 {
10134 if (temp2)
10135 delete arg2;
10136 }
10137 return NULL;
10138 }
10139
10140
10141 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10142 PyObject *resultobj = 0;
10143 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10144 wxString result;
10145 void *argp1 = 0 ;
10146 int res1 = 0 ;
10147 PyObject *swig_obj[1] ;
10148
10149 if (!args) SWIG_fail;
10150 swig_obj[0] = args;
10151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10152 if (!SWIG_IsOK(res1)) {
10153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10154 }
10155 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 result = (arg1)->FindNext();
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 {
10163 #if wxUSE_UNICODE
10164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10165 #else
10166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10167 #endif
10168 }
10169 return resultobj;
10170 fail:
10171 return NULL;
10172 }
10173
10174
10175 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj = 0;
10177 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10178 wxString *arg2 = 0 ;
10179 wxString result;
10180 void *argp1 = 0 ;
10181 int res1 = 0 ;
10182 bool temp2 = false ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char * kwnames[] = {
10186 (char *) "self",(char *) "location", NULL
10187 };
10188
10189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10193 }
10194 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10195 {
10196 arg2 = wxString_in_helper(obj1);
10197 if (arg2 == NULL) SWIG_fail;
10198 temp2 = true;
10199 }
10200 {
10201 PyThreadState* __tstate = wxPyBeginAllowThreads();
10202 result = (arg1)->GetProtocol((wxString const &)*arg2);
10203 wxPyEndAllowThreads(__tstate);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 {
10207 #if wxUSE_UNICODE
10208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10209 #else
10210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10211 #endif
10212 }
10213 {
10214 if (temp2)
10215 delete arg2;
10216 }
10217 return resultobj;
10218 fail:
10219 {
10220 if (temp2)
10221 delete arg2;
10222 }
10223 return NULL;
10224 }
10225
10226
10227 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = 0;
10229 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10230 wxString *arg2 = 0 ;
10231 wxString result;
10232 void *argp1 = 0 ;
10233 int res1 = 0 ;
10234 bool temp2 = false ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "location", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10245 }
10246 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10247 {
10248 arg2 = wxString_in_helper(obj1);
10249 if (arg2 == NULL) SWIG_fail;
10250 temp2 = true;
10251 }
10252 {
10253 PyThreadState* __tstate = wxPyBeginAllowThreads();
10254 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 {
10259 #if wxUSE_UNICODE
10260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10261 #else
10262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10263 #endif
10264 }
10265 {
10266 if (temp2)
10267 delete arg2;
10268 }
10269 return resultobj;
10270 fail:
10271 {
10272 if (temp2)
10273 delete arg2;
10274 }
10275 return NULL;
10276 }
10277
10278
10279 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10280 PyObject *resultobj = 0;
10281 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10282 wxString *arg2 = 0 ;
10283 wxString result;
10284 void *argp1 = 0 ;
10285 int res1 = 0 ;
10286 bool temp2 = false ;
10287 PyObject * obj0 = 0 ;
10288 PyObject * obj1 = 0 ;
10289 char * kwnames[] = {
10290 (char *) "self",(char *) "location", NULL
10291 };
10292
10293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10295 if (!SWIG_IsOK(res1)) {
10296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10297 }
10298 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10299 {
10300 arg2 = wxString_in_helper(obj1);
10301 if (arg2 == NULL) SWIG_fail;
10302 temp2 = true;
10303 }
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (arg1)->GetAnchor((wxString const &)*arg2);
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 {
10311 #if wxUSE_UNICODE
10312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10313 #else
10314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10315 #endif
10316 }
10317 {
10318 if (temp2)
10319 delete arg2;
10320 }
10321 return resultobj;
10322 fail:
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return NULL;
10328 }
10329
10330
10331 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10332 PyObject *resultobj = 0;
10333 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10334 wxString *arg2 = 0 ;
10335 wxString result;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 bool temp2 = false ;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "location", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10349 }
10350 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10351 {
10352 arg2 = wxString_in_helper(obj1);
10353 if (arg2 == NULL) SWIG_fail;
10354 temp2 = true;
10355 }
10356 {
10357 PyThreadState* __tstate = wxPyBeginAllowThreads();
10358 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10359 wxPyEndAllowThreads(__tstate);
10360 if (PyErr_Occurred()) SWIG_fail;
10361 }
10362 {
10363 #if wxUSE_UNICODE
10364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10365 #else
10366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10367 #endif
10368 }
10369 {
10370 if (temp2)
10371 delete arg2;
10372 }
10373 return resultobj;
10374 fail:
10375 {
10376 if (temp2)
10377 delete arg2;
10378 }
10379 return NULL;
10380 }
10381
10382
10383 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10384 PyObject *resultobj = 0;
10385 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10386 wxString *arg2 = 0 ;
10387 wxString result;
10388 void *argp1 = 0 ;
10389 int res1 = 0 ;
10390 bool temp2 = false ;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 char * kwnames[] = {
10394 (char *) "self",(char *) "location", NULL
10395 };
10396
10397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10399 if (!SWIG_IsOK(res1)) {
10400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10401 }
10402 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10403 {
10404 arg2 = wxString_in_helper(obj1);
10405 if (arg2 == NULL) SWIG_fail;
10406 temp2 = true;
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 {
10415 #if wxUSE_UNICODE
10416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10417 #else
10418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10419 #endif
10420 }
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return resultobj;
10426 fail:
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10436 PyObject *obj;
10437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10438 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10439 return SWIG_Py_Void();
10440 }
10441
10442 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10443 return SWIG_Python_InitShadowInstance(args);
10444 }
10445
10446 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10447 PyObject *resultobj = 0;
10448 wxFileSystem *result = 0 ;
10449
10450 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (wxFileSystem *)new wxFileSystem();
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 {
10458 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10459 }
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10467 PyObject *resultobj = 0;
10468 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10469 void *argp1 = 0 ;
10470 int res1 = 0 ;
10471 PyObject *swig_obj[1] ;
10472
10473 if (!args) SWIG_fail;
10474 swig_obj[0] = args;
10475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10476 if (!SWIG_IsOK(res1)) {
10477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10478 }
10479 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10480 {
10481 PyThreadState* __tstate = wxPyBeginAllowThreads();
10482 delete arg1;
10483
10484 wxPyEndAllowThreads(__tstate);
10485 if (PyErr_Occurred()) SWIG_fail;
10486 }
10487 resultobj = SWIG_Py_Void();
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj = 0;
10496 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10497 wxString *arg2 = 0 ;
10498 bool arg3 = (bool) false ;
10499 void *argp1 = 0 ;
10500 int res1 = 0 ;
10501 bool temp2 = false ;
10502 bool val3 ;
10503 int ecode3 = 0 ;
10504 PyObject * obj0 = 0 ;
10505 PyObject * obj1 = 0 ;
10506 PyObject * obj2 = 0 ;
10507 char * kwnames[] = {
10508 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10509 };
10510
10511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10513 if (!SWIG_IsOK(res1)) {
10514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10515 }
10516 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10517 {
10518 arg2 = wxString_in_helper(obj1);
10519 if (arg2 == NULL) SWIG_fail;
10520 temp2 = true;
10521 }
10522 if (obj2) {
10523 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10524 if (!SWIG_IsOK(ecode3)) {
10525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10526 }
10527 arg3 = static_cast< bool >(val3);
10528 }
10529 {
10530 PyThreadState* __tstate = wxPyBeginAllowThreads();
10531 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10532 wxPyEndAllowThreads(__tstate);
10533 if (PyErr_Occurred()) SWIG_fail;
10534 }
10535 resultobj = SWIG_Py_Void();
10536 {
10537 if (temp2)
10538 delete arg2;
10539 }
10540 return resultobj;
10541 fail:
10542 {
10543 if (temp2)
10544 delete arg2;
10545 }
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10551 PyObject *resultobj = 0;
10552 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10553 wxString result;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 PyObject *swig_obj[1] ;
10557
10558 if (!args) SWIG_fail;
10559 swig_obj[0] = args;
10560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10561 if (!SWIG_IsOK(res1)) {
10562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10563 }
10564 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = (arg1)->GetPath();
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 {
10572 #if wxUSE_UNICODE
10573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10574 #else
10575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10576 #endif
10577 }
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj = 0;
10586 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10587 wxString *arg2 = 0 ;
10588 wxFSFile *result = 0 ;
10589 void *argp1 = 0 ;
10590 int res1 = 0 ;
10591 bool temp2 = false ;
10592 PyObject * obj0 = 0 ;
10593 PyObject * obj1 = 0 ;
10594 char * kwnames[] = {
10595 (char *) "self",(char *) "location", NULL
10596 };
10597
10598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10600 if (!SWIG_IsOK(res1)) {
10601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10602 }
10603 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10604 {
10605 arg2 = wxString_in_helper(obj1);
10606 if (arg2 == NULL) SWIG_fail;
10607 temp2 = true;
10608 }
10609 {
10610 PyThreadState* __tstate = wxPyBeginAllowThreads();
10611 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10612 wxPyEndAllowThreads(__tstate);
10613 if (PyErr_Occurred()) SWIG_fail;
10614 }
10615 {
10616 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10617 }
10618 {
10619 if (temp2)
10620 delete arg2;
10621 }
10622 return resultobj;
10623 fail:
10624 {
10625 if (temp2)
10626 delete arg2;
10627 }
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj = 0;
10634 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10635 wxString *arg2 = 0 ;
10636 int arg3 = (int) 0 ;
10637 wxString result;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 bool temp2 = false ;
10641 int val3 ;
10642 int ecode3 = 0 ;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 char * kwnames[] = {
10647 (char *) "self",(char *) "spec",(char *) "flags", NULL
10648 };
10649
10650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10654 }
10655 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10656 {
10657 arg2 = wxString_in_helper(obj1);
10658 if (arg2 == NULL) SWIG_fail;
10659 temp2 = true;
10660 }
10661 if (obj2) {
10662 ecode3 = SWIG_AsVal_int(obj2, &val3);
10663 if (!SWIG_IsOK(ecode3)) {
10664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10665 }
10666 arg3 = static_cast< int >(val3);
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 {
10675 #if wxUSE_UNICODE
10676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10677 #else
10678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10679 #endif
10680 }
10681 {
10682 if (temp2)
10683 delete arg2;
10684 }
10685 return resultobj;
10686 fail:
10687 {
10688 if (temp2)
10689 delete arg2;
10690 }
10691 return NULL;
10692 }
10693
10694
10695 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 PyObject *resultobj = 0;
10697 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10698 wxString result;
10699 void *argp1 = 0 ;
10700 int res1 = 0 ;
10701 PyObject *swig_obj[1] ;
10702
10703 if (!args) SWIG_fail;
10704 swig_obj[0] = args;
10705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10708 }
10709 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (arg1)->FindNext();
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 {
10717 #if wxUSE_UNICODE
10718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10719 #else
10720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10721 #endif
10722 }
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = 0;
10731 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10732 int res1 = 0 ;
10733 PyObject * obj0 = 0 ;
10734 char * kwnames[] = {
10735 (char *) "handler", NULL
10736 };
10737
10738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10739 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10740 if (!SWIG_IsOK(res1)) {
10741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10742 }
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 wxFileSystem::AddHandler(arg1);
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 resultobj = SWIG_Py_Void();
10750 return resultobj;
10751 fail:
10752 return NULL;
10753 }
10754
10755
10756 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10757 PyObject *resultobj = 0;
10758
10759 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 wxFileSystem::CleanUpHandlers();
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_Py_Void();
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj = 0;
10775 wxString *arg1 = 0 ;
10776 wxString result;
10777 bool temp1 = false ;
10778 PyObject * obj0 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "filename", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10784 {
10785 arg1 = wxString_in_helper(obj0);
10786 if (arg1 == NULL) SWIG_fail;
10787 temp1 = true;
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 #if wxUSE_UNICODE
10797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10798 #else
10799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10800 #endif
10801 }
10802 {
10803 if (temp1)
10804 delete arg1;
10805 }
10806 return resultobj;
10807 fail:
10808 {
10809 if (temp1)
10810 delete arg1;
10811 }
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10817 PyObject *resultobj = 0;
10818 wxString *arg1 = 0 ;
10819 wxString result;
10820 bool temp1 = false ;
10821 PyObject * obj0 = 0 ;
10822 char * kwnames[] = {
10823 (char *) "url", NULL
10824 };
10825
10826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10827 {
10828 arg1 = wxString_in_helper(obj0);
10829 if (arg1 == NULL) SWIG_fail;
10830 temp1 = true;
10831 }
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 {
10839 #if wxUSE_UNICODE
10840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10841 #else
10842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10843 #endif
10844 }
10845 {
10846 if (temp1)
10847 delete arg1;
10848 }
10849 return resultobj;
10850 fail:
10851 {
10852 if (temp1)
10853 delete arg1;
10854 }
10855 return NULL;
10856 }
10857
10858
10859 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10860 PyObject *obj;
10861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10862 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10863 return SWIG_Py_Void();
10864 }
10865
10866 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10867 return SWIG_Python_InitShadowInstance(args);
10868 }
10869
10870 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10871 PyObject *resultobj = 0;
10872 wxInternetFSHandler *result = 0 ;
10873
10874 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10891 wxString *arg2 = 0 ;
10892 bool result;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 bool temp2 = false ;
10896 PyObject * obj0 = 0 ;
10897 PyObject * obj1 = 0 ;
10898 char * kwnames[] = {
10899 (char *) "self",(char *) "location", NULL
10900 };
10901
10902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10904 if (!SWIG_IsOK(res1)) {
10905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10906 }
10907 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10908 {
10909 arg2 = wxString_in_helper(obj1);
10910 if (arg2 == NULL) SWIG_fail;
10911 temp2 = true;
10912 }
10913 {
10914 PyThreadState* __tstate = wxPyBeginAllowThreads();
10915 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10916 wxPyEndAllowThreads(__tstate);
10917 if (PyErr_Occurred()) SWIG_fail;
10918 }
10919 {
10920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10921 }
10922 {
10923 if (temp2)
10924 delete arg2;
10925 }
10926 return resultobj;
10927 fail:
10928 {
10929 if (temp2)
10930 delete arg2;
10931 }
10932 return NULL;
10933 }
10934
10935
10936 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj = 0;
10938 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10939 wxFileSystem *arg2 = 0 ;
10940 wxString *arg3 = 0 ;
10941 wxFSFile *result = 0 ;
10942 void *argp1 = 0 ;
10943 int res1 = 0 ;
10944 void *argp2 = 0 ;
10945 int res2 = 0 ;
10946 bool temp3 = false ;
10947 PyObject * obj0 = 0 ;
10948 PyObject * obj1 = 0 ;
10949 PyObject * obj2 = 0 ;
10950 char * kwnames[] = {
10951 (char *) "self",(char *) "fs",(char *) "location", NULL
10952 };
10953
10954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10956 if (!SWIG_IsOK(res1)) {
10957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10958 }
10959 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10961 if (!SWIG_IsOK(res2)) {
10962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10963 }
10964 if (!argp2) {
10965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10966 }
10967 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10968 {
10969 arg3 = wxString_in_helper(obj2);
10970 if (arg3 == NULL) SWIG_fail;
10971 temp3 = true;
10972 }
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 {
10980 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10981 }
10982 {
10983 if (temp3)
10984 delete arg3;
10985 }
10986 return resultobj;
10987 fail:
10988 {
10989 if (temp3)
10990 delete arg3;
10991 }
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10997 PyObject *obj;
10998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10999 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11000 return SWIG_Py_Void();
11001 }
11002
11003 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 return SWIG_Python_InitShadowInstance(args);
11005 }
11006
11007 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008 PyObject *resultobj = 0;
11009 wxZipFSHandler *result = 0 ;
11010
11011 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11012 {
11013 PyThreadState* __tstate = wxPyBeginAllowThreads();
11014 result = (wxZipFSHandler *)new wxZipFSHandler();
11015 wxPyEndAllowThreads(__tstate);
11016 if (PyErr_Occurred()) SWIG_fail;
11017 }
11018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj = 0;
11027 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11028 wxString *arg2 = 0 ;
11029 bool result;
11030 void *argp1 = 0 ;
11031 int res1 = 0 ;
11032 bool temp2 = false ;
11033 PyObject * obj0 = 0 ;
11034 PyObject * obj1 = 0 ;
11035 char * kwnames[] = {
11036 (char *) "self",(char *) "location", NULL
11037 };
11038
11039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11041 if (!SWIG_IsOK(res1)) {
11042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11043 }
11044 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11045 {
11046 arg2 = wxString_in_helper(obj1);
11047 if (arg2 == NULL) SWIG_fail;
11048 temp2 = true;
11049 }
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11058 }
11059 {
11060 if (temp2)
11061 delete arg2;
11062 }
11063 return resultobj;
11064 fail:
11065 {
11066 if (temp2)
11067 delete arg2;
11068 }
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj = 0;
11075 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11076 wxFileSystem *arg2 = 0 ;
11077 wxString *arg3 = 0 ;
11078 wxFSFile *result = 0 ;
11079 void *argp1 = 0 ;
11080 int res1 = 0 ;
11081 void *argp2 = 0 ;
11082 int res2 = 0 ;
11083 bool temp3 = false ;
11084 PyObject * obj0 = 0 ;
11085 PyObject * obj1 = 0 ;
11086 PyObject * obj2 = 0 ;
11087 char * kwnames[] = {
11088 (char *) "self",(char *) "fs",(char *) "location", NULL
11089 };
11090
11091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11093 if (!SWIG_IsOK(res1)) {
11094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11095 }
11096 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11098 if (!SWIG_IsOK(res2)) {
11099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11100 }
11101 if (!argp2) {
11102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11103 }
11104 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11105 {
11106 arg3 = wxString_in_helper(obj2);
11107 if (arg3 == NULL) SWIG_fail;
11108 temp3 = true;
11109 }
11110 {
11111 PyThreadState* __tstate = wxPyBeginAllowThreads();
11112 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11113 wxPyEndAllowThreads(__tstate);
11114 if (PyErr_Occurred()) SWIG_fail;
11115 }
11116 {
11117 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11118 }
11119 {
11120 if (temp3)
11121 delete arg3;
11122 }
11123 return resultobj;
11124 fail:
11125 {
11126 if (temp3)
11127 delete arg3;
11128 }
11129 return NULL;
11130 }
11131
11132
11133 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11134 PyObject *resultobj = 0;
11135 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11136 wxString *arg2 = 0 ;
11137 int arg3 = (int) 0 ;
11138 wxString result;
11139 void *argp1 = 0 ;
11140 int res1 = 0 ;
11141 bool temp2 = false ;
11142 int val3 ;
11143 int ecode3 = 0 ;
11144 PyObject * obj0 = 0 ;
11145 PyObject * obj1 = 0 ;
11146 PyObject * obj2 = 0 ;
11147 char * kwnames[] = {
11148 (char *) "self",(char *) "spec",(char *) "flags", NULL
11149 };
11150
11151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11153 if (!SWIG_IsOK(res1)) {
11154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11155 }
11156 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11157 {
11158 arg2 = wxString_in_helper(obj1);
11159 if (arg2 == NULL) SWIG_fail;
11160 temp2 = true;
11161 }
11162 if (obj2) {
11163 ecode3 = SWIG_AsVal_int(obj2, &val3);
11164 if (!SWIG_IsOK(ecode3)) {
11165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11166 }
11167 arg3 = static_cast< int >(val3);
11168 }
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 #if wxUSE_UNICODE
11177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11178 #else
11179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11180 #endif
11181 }
11182 {
11183 if (temp2)
11184 delete arg2;
11185 }
11186 return resultobj;
11187 fail:
11188 {
11189 if (temp2)
11190 delete arg2;
11191 }
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11199 wxString result;
11200 void *argp1 = 0 ;
11201 int res1 = 0 ;
11202 PyObject *swig_obj[1] ;
11203
11204 if (!args) SWIG_fail;
11205 swig_obj[0] = args;
11206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11207 if (!SWIG_IsOK(res1)) {
11208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11209 }
11210 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11211 {
11212 PyThreadState* __tstate = wxPyBeginAllowThreads();
11213 result = (arg1)->FindNext();
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 {
11218 #if wxUSE_UNICODE
11219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11220 #else
11221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11222 #endif
11223 }
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11231 PyObject *obj;
11232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11233 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11234 return SWIG_Py_Void();
11235 }
11236
11237 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11238 return SWIG_Python_InitShadowInstance(args);
11239 }
11240
11241 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj = 0;
11243 wxString *arg1 = 0 ;
11244 wxImage *arg2 = 0 ;
11245 long arg3 ;
11246 bool temp1 = false ;
11247 void *argp2 = 0 ;
11248 int res2 = 0 ;
11249 long val3 ;
11250 int ecode3 = 0 ;
11251 PyObject * obj0 = 0 ;
11252 PyObject * obj1 = 0 ;
11253 PyObject * obj2 = 0 ;
11254 char * kwnames[] = {
11255 (char *) "filename",(char *) "image",(char *) "type", NULL
11256 };
11257
11258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11259 {
11260 arg1 = wxString_in_helper(obj0);
11261 if (arg1 == NULL) SWIG_fail;
11262 temp1 = true;
11263 }
11264 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11265 if (!SWIG_IsOK(res2)) {
11266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11267 }
11268 if (!argp2) {
11269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11270 }
11271 arg2 = reinterpret_cast< wxImage * >(argp2);
11272 ecode3 = SWIG_AsVal_long(obj2, &val3);
11273 if (!SWIG_IsOK(ecode3)) {
11274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11275 }
11276 arg3 = static_cast< long >(val3);
11277 {
11278 PyThreadState* __tstate = wxPyBeginAllowThreads();
11279 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 resultobj = SWIG_Py_Void();
11284 {
11285 if (temp1)
11286 delete arg1;
11287 }
11288 return resultobj;
11289 fail:
11290 {
11291 if (temp1)
11292 delete arg1;
11293 }
11294 return NULL;
11295 }
11296
11297
11298 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11299 PyObject *resultobj = 0;
11300 wxString *arg1 = 0 ;
11301 wxBitmap *arg2 = 0 ;
11302 long arg3 ;
11303 bool temp1 = false ;
11304 void *argp2 = 0 ;
11305 int res2 = 0 ;
11306 long val3 ;
11307 int ecode3 = 0 ;
11308 PyObject * obj0 = 0 ;
11309 PyObject * obj1 = 0 ;
11310 PyObject * obj2 = 0 ;
11311 char * kwnames[] = {
11312 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11313 };
11314
11315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11316 {
11317 arg1 = wxString_in_helper(obj0);
11318 if (arg1 == NULL) SWIG_fail;
11319 temp1 = true;
11320 }
11321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11322 if (!SWIG_IsOK(res2)) {
11323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11324 }
11325 if (!argp2) {
11326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11327 }
11328 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11329 ecode3 = SWIG_AsVal_long(obj2, &val3);
11330 if (!SWIG_IsOK(ecode3)) {
11331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11332 }
11333 arg3 = static_cast< long >(val3);
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 {
11342 if (temp1)
11343 delete arg1;
11344 }
11345 return resultobj;
11346 fail:
11347 {
11348 if (temp1)
11349 delete arg1;
11350 }
11351 return NULL;
11352 }
11353
11354
11355 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj = 0;
11357 wxString *arg1 = 0 ;
11358 PyObject *arg2 = (PyObject *) 0 ;
11359 bool temp1 = false ;
11360 PyObject * obj0 = 0 ;
11361 PyObject * obj1 = 0 ;
11362 char * kwnames[] = {
11363 (char *) "filename",(char *) "data", NULL
11364 };
11365
11366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11367 {
11368 arg1 = wxString_in_helper(obj0);
11369 if (arg1 == NULL) SWIG_fail;
11370 temp1 = true;
11371 }
11372 arg2 = obj1;
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11376 wxPyEndAllowThreads(__tstate);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 resultobj = SWIG_Py_Void();
11380 {
11381 if (temp1)
11382 delete arg1;
11383 }
11384 return resultobj;
11385 fail:
11386 {
11387 if (temp1)
11388 delete arg1;
11389 }
11390 return NULL;
11391 }
11392
11393
11394 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11395 PyObject *resultobj = 0;
11396 wxMemoryFSHandler *result = 0 ;
11397
11398 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11406 return resultobj;
11407 fail:
11408 return NULL;
11409 }
11410
11411
11412 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11413 PyObject *resultobj = 0;
11414 wxString *arg1 = 0 ;
11415 bool temp1 = false ;
11416 PyObject * obj0 = 0 ;
11417 char * kwnames[] = {
11418 (char *) "filename", NULL
11419 };
11420
11421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11430 wxPyEndAllowThreads(__tstate);
11431 if (PyErr_Occurred()) SWIG_fail;
11432 }
11433 resultobj = SWIG_Py_Void();
11434 {
11435 if (temp1)
11436 delete arg1;
11437 }
11438 return resultobj;
11439 fail:
11440 {
11441 if (temp1)
11442 delete arg1;
11443 }
11444 return NULL;
11445 }
11446
11447
11448 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11449 PyObject *resultobj = 0;
11450 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11451 wxString *arg2 = 0 ;
11452 bool result;
11453 void *argp1 = 0 ;
11454 int res1 = 0 ;
11455 bool temp2 = false ;
11456 PyObject * obj0 = 0 ;
11457 PyObject * obj1 = 0 ;
11458 char * kwnames[] = {
11459 (char *) "self",(char *) "location", NULL
11460 };
11461
11462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11464 if (!SWIG_IsOK(res1)) {
11465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11466 }
11467 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11468 {
11469 arg2 = wxString_in_helper(obj1);
11470 if (arg2 == NULL) SWIG_fail;
11471 temp2 = true;
11472 }
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11476 wxPyEndAllowThreads(__tstate);
11477 if (PyErr_Occurred()) SWIG_fail;
11478 }
11479 {
11480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11481 }
11482 {
11483 if (temp2)
11484 delete arg2;
11485 }
11486 return resultobj;
11487 fail:
11488 {
11489 if (temp2)
11490 delete arg2;
11491 }
11492 return NULL;
11493 }
11494
11495
11496 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj = 0;
11498 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11499 wxFileSystem *arg2 = 0 ;
11500 wxString *arg3 = 0 ;
11501 wxFSFile *result = 0 ;
11502 void *argp1 = 0 ;
11503 int res1 = 0 ;
11504 void *argp2 = 0 ;
11505 int res2 = 0 ;
11506 bool temp3 = false ;
11507 PyObject * obj0 = 0 ;
11508 PyObject * obj1 = 0 ;
11509 PyObject * obj2 = 0 ;
11510 char * kwnames[] = {
11511 (char *) "self",(char *) "fs",(char *) "location", NULL
11512 };
11513
11514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11516 if (!SWIG_IsOK(res1)) {
11517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11518 }
11519 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11520 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11521 if (!SWIG_IsOK(res2)) {
11522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11523 }
11524 if (!argp2) {
11525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11526 }
11527 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11528 {
11529 arg3 = wxString_in_helper(obj2);
11530 if (arg3 == NULL) SWIG_fail;
11531 temp3 = true;
11532 }
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 {
11540 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11541 }
11542 {
11543 if (temp3)
11544 delete arg3;
11545 }
11546 return resultobj;
11547 fail:
11548 {
11549 if (temp3)
11550 delete arg3;
11551 }
11552 return NULL;
11553 }
11554
11555
11556 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11557 PyObject *resultobj = 0;
11558 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11559 wxString *arg2 = 0 ;
11560 int arg3 = (int) 0 ;
11561 wxString result;
11562 void *argp1 = 0 ;
11563 int res1 = 0 ;
11564 bool temp2 = false ;
11565 int val3 ;
11566 int ecode3 = 0 ;
11567 PyObject * obj0 = 0 ;
11568 PyObject * obj1 = 0 ;
11569 PyObject * obj2 = 0 ;
11570 char * kwnames[] = {
11571 (char *) "self",(char *) "spec",(char *) "flags", NULL
11572 };
11573
11574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11576 if (!SWIG_IsOK(res1)) {
11577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11578 }
11579 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11580 {
11581 arg2 = wxString_in_helper(obj1);
11582 if (arg2 == NULL) SWIG_fail;
11583 temp2 = true;
11584 }
11585 if (obj2) {
11586 ecode3 = SWIG_AsVal_int(obj2, &val3);
11587 if (!SWIG_IsOK(ecode3)) {
11588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11589 }
11590 arg3 = static_cast< int >(val3);
11591 }
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 {
11599 #if wxUSE_UNICODE
11600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11601 #else
11602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11603 #endif
11604 }
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 return resultobj;
11610 fail:
11611 {
11612 if (temp2)
11613 delete arg2;
11614 }
11615 return NULL;
11616 }
11617
11618
11619 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11620 PyObject *resultobj = 0;
11621 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11622 wxString result;
11623 void *argp1 = 0 ;
11624 int res1 = 0 ;
11625 PyObject *swig_obj[1] ;
11626
11627 if (!args) SWIG_fail;
11628 swig_obj[0] = args;
11629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11630 if (!SWIG_IsOK(res1)) {
11631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11632 }
11633 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (arg1)->FindNext();
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 #if wxUSE_UNICODE
11642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11643 #else
11644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11645 #endif
11646 }
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11654 PyObject *obj;
11655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11656 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11657 return SWIG_Py_Void();
11658 }
11659
11660 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11661 return SWIG_Python_InitShadowInstance(args);
11662 }
11663
11664 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11665 PyObject *resultobj = 0;
11666 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11667 wxString result;
11668 void *argp1 = 0 ;
11669 int res1 = 0 ;
11670 PyObject *swig_obj[1] ;
11671
11672 if (!args) SWIG_fail;
11673 swig_obj[0] = args;
11674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11675 if (!SWIG_IsOK(res1)) {
11676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11677 }
11678 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11679 {
11680 PyThreadState* __tstate = wxPyBeginAllowThreads();
11681 result = (arg1)->GetName();
11682 wxPyEndAllowThreads(__tstate);
11683 if (PyErr_Occurred()) SWIG_fail;
11684 }
11685 {
11686 #if wxUSE_UNICODE
11687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11688 #else
11689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11690 #endif
11691 }
11692 return resultobj;
11693 fail:
11694 return NULL;
11695 }
11696
11697
11698 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699 PyObject *resultobj = 0;
11700 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11701 wxString result;
11702 void *argp1 = 0 ;
11703 int res1 = 0 ;
11704 PyObject *swig_obj[1] ;
11705
11706 if (!args) SWIG_fail;
11707 swig_obj[0] = args;
11708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11711 }
11712 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11713 {
11714 PyThreadState* __tstate = wxPyBeginAllowThreads();
11715 result = (arg1)->GetExtension();
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 {
11720 #if wxUSE_UNICODE
11721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11722 #else
11723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11724 #endif
11725 }
11726 return resultobj;
11727 fail:
11728 return NULL;
11729 }
11730
11731
11732 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733 PyObject *resultobj = 0;
11734 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11735 long result;
11736 void *argp1 = 0 ;
11737 int res1 = 0 ;
11738 PyObject *swig_obj[1] ;
11739
11740 if (!args) SWIG_fail;
11741 swig_obj[0] = args;
11742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11743 if (!SWIG_IsOK(res1)) {
11744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11745 }
11746 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (long)(arg1)->GetType();
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = SWIG_From_long(static_cast< long >(result));
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11761 PyObject *resultobj = 0;
11762 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11763 wxString result;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 PyObject *swig_obj[1] ;
11767
11768 if (!args) SWIG_fail;
11769 swig_obj[0] = args;
11770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11773 }
11774 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (arg1)->GetMimeType();
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 #if wxUSE_UNICODE
11783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11784 #else
11785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11786 #endif
11787 }
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11795 PyObject *resultobj = 0;
11796 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11797 wxString *arg2 = 0 ;
11798 bool result;
11799 void *argp1 = 0 ;
11800 int res1 = 0 ;
11801 bool temp2 = false ;
11802 PyObject * obj0 = 0 ;
11803 PyObject * obj1 = 0 ;
11804 char * kwnames[] = {
11805 (char *) "self",(char *) "name", NULL
11806 };
11807
11808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11812 }
11813 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11814 {
11815 arg2 = wxString_in_helper(obj1);
11816 if (arg2 == NULL) SWIG_fail;
11817 temp2 = true;
11818 }
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11822 wxPyEndAllowThreads(__tstate);
11823 if (PyErr_Occurred()) SWIG_fail;
11824 }
11825 {
11826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11827 }
11828 {
11829 if (temp2)
11830 delete arg2;
11831 }
11832 return resultobj;
11833 fail:
11834 {
11835 if (temp2)
11836 delete arg2;
11837 }
11838 return NULL;
11839 }
11840
11841
11842 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11843 PyObject *resultobj = 0;
11844 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11845 wxString *arg2 = 0 ;
11846 void *argp1 = 0 ;
11847 int res1 = 0 ;
11848 bool temp2 = false ;
11849 PyObject * obj0 = 0 ;
11850 PyObject * obj1 = 0 ;
11851 char * kwnames[] = {
11852 (char *) "self",(char *) "name", NULL
11853 };
11854
11855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11859 }
11860 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11861 {
11862 arg2 = wxString_in_helper(obj1);
11863 if (arg2 == NULL) SWIG_fail;
11864 temp2 = true;
11865 }
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 (arg1)->SetName((wxString const &)*arg2);
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 resultobj = SWIG_Py_Void();
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp2)
11881 delete arg2;
11882 }
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj = 0;
11889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11890 wxString *arg2 = 0 ;
11891 void *argp1 = 0 ;
11892 int res1 = 0 ;
11893 bool temp2 = false ;
11894 PyObject * obj0 = 0 ;
11895 PyObject * obj1 = 0 ;
11896 char * kwnames[] = {
11897 (char *) "self",(char *) "extension", NULL
11898 };
11899
11900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11902 if (!SWIG_IsOK(res1)) {
11903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11904 }
11905 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11906 {
11907 arg2 = wxString_in_helper(obj1);
11908 if (arg2 == NULL) SWIG_fail;
11909 temp2 = true;
11910 }
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 (arg1)->SetExtension((wxString const &)*arg2);
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 resultobj = SWIG_Py_Void();
11918 {
11919 if (temp2)
11920 delete arg2;
11921 }
11922 return resultobj;
11923 fail:
11924 {
11925 if (temp2)
11926 delete arg2;
11927 }
11928 return NULL;
11929 }
11930
11931
11932 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj = 0;
11934 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11935 long arg2 ;
11936 void *argp1 = 0 ;
11937 int res1 = 0 ;
11938 long val2 ;
11939 int ecode2 = 0 ;
11940 PyObject * obj0 = 0 ;
11941 PyObject * obj1 = 0 ;
11942 char * kwnames[] = {
11943 (char *) "self",(char *) "type", NULL
11944 };
11945
11946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11948 if (!SWIG_IsOK(res1)) {
11949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11950 }
11951 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11952 ecode2 = SWIG_AsVal_long(obj1, &val2);
11953 if (!SWIG_IsOK(ecode2)) {
11954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11955 }
11956 arg2 = static_cast< long >(val2);
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 (arg1)->SetType(arg2);
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 resultobj = SWIG_Py_Void();
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj = 0;
11972 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11973 wxString *arg2 = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 bool temp2 = false ;
11977 PyObject * obj0 = 0 ;
11978 PyObject * obj1 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "self",(char *) "mimetype", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11987 }
11988 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11989 {
11990 arg2 = wxString_in_helper(obj1);
11991 if (arg2 == NULL) SWIG_fail;
11992 temp2 = true;
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 (arg1)->SetMimeType((wxString const &)*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 resultobj = SWIG_Py_Void();
12001 {
12002 if (temp2)
12003 delete arg2;
12004 }
12005 return resultobj;
12006 fail:
12007 {
12008 if (temp2)
12009 delete arg2;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12016 PyObject *obj;
12017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12018 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12019 return SWIG_Py_Void();
12020 }
12021
12022 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12023 PyObject *resultobj = 0;
12024 wxPyImageHandler *result = 0 ;
12025
12026 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (wxPyImageHandler *)new wxPyImageHandler();
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12043 PyObject *arg2 = (PyObject *) 0 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 char * kwnames[] = {
12049 (char *) "self",(char *) "self", NULL
12050 };
12051
12052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12056 }
12057 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12058 arg2 = obj1;
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 (arg1)->_SetSelf(arg2);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_Py_Void();
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *obj;
12074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12075 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12076 return SWIG_Py_Void();
12077 }
12078
12079 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 return SWIG_Python_InitShadowInstance(args);
12081 }
12082
12083 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12084 PyObject *resultobj = 0;
12085 wxImageHistogram *result = 0 ;
12086
12087 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 result = (wxImageHistogram *)new wxImageHistogram();
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj = 0;
12103 byte arg1 ;
12104 byte arg2 ;
12105 byte arg3 ;
12106 unsigned long result;
12107 unsigned char val1 ;
12108 int ecode1 = 0 ;
12109 unsigned char val2 ;
12110 int ecode2 = 0 ;
12111 unsigned char val3 ;
12112 int ecode3 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 PyObject * obj2 = 0 ;
12116 char * kwnames[] = {
12117 (char *) "r",(char *) "g",(char *) "b", NULL
12118 };
12119
12120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12121 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12122 if (!SWIG_IsOK(ecode1)) {
12123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12124 }
12125 arg1 = static_cast< byte >(val1);
12126 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12127 if (!SWIG_IsOK(ecode2)) {
12128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12129 }
12130 arg2 = static_cast< byte >(val2);
12131 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12132 if (!SWIG_IsOK(ecode3)) {
12133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12134 }
12135 arg3 = static_cast< byte >(val3);
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12143 return resultobj;
12144 fail:
12145 return NULL;
12146 }
12147
12148
12149 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12150 PyObject *resultobj = 0;
12151 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12152 byte *arg2 = (byte *) 0 ;
12153 byte *arg3 = (byte *) 0 ;
12154 byte *arg4 = (byte *) 0 ;
12155 byte arg5 = (byte) 1 ;
12156 byte arg6 = (byte) 0 ;
12157 byte arg7 = (byte) 0 ;
12158 bool result;
12159 void *argp1 = 0 ;
12160 int res1 = 0 ;
12161 byte temp2 ;
12162 int res2 = SWIG_TMPOBJ ;
12163 byte temp3 ;
12164 int res3 = SWIG_TMPOBJ ;
12165 byte temp4 ;
12166 int res4 = SWIG_TMPOBJ ;
12167 unsigned char val5 ;
12168 int ecode5 = 0 ;
12169 unsigned char val6 ;
12170 int ecode6 = 0 ;
12171 unsigned char val7 ;
12172 int ecode7 = 0 ;
12173 PyObject * obj0 = 0 ;
12174 PyObject * obj1 = 0 ;
12175 PyObject * obj2 = 0 ;
12176 PyObject * obj3 = 0 ;
12177 char * kwnames[] = {
12178 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12179 };
12180
12181 arg2 = &temp2;
12182 arg3 = &temp3;
12183 arg4 = &temp4;
12184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12186 if (!SWIG_IsOK(res1)) {
12187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12188 }
12189 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12190 if (obj1) {
12191 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12192 if (!SWIG_IsOK(ecode5)) {
12193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12194 }
12195 arg5 = static_cast< byte >(val5);
12196 }
12197 if (obj2) {
12198 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12199 if (!SWIG_IsOK(ecode6)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12201 }
12202 arg6 = static_cast< byte >(val6);
12203 }
12204 if (obj3) {
12205 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12206 if (!SWIG_IsOK(ecode7)) {
12207 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12208 }
12209 arg7 = static_cast< byte >(val7);
12210 }
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12219 }
12220 if (SWIG_IsTmpObj(res2)) {
12221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12222 } else {
12223 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12225 }
12226 if (SWIG_IsTmpObj(res3)) {
12227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12228 } else {
12229 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12231 }
12232 if (SWIG_IsTmpObj(res4)) {
12233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12234 } else {
12235 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12237 }
12238 return resultobj;
12239 fail:
12240 return NULL;
12241 }
12242
12243
12244 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj = 0;
12246 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12247 unsigned long arg2 ;
12248 unsigned long result;
12249 void *argp1 = 0 ;
12250 int res1 = 0 ;
12251 unsigned long val2 ;
12252 int ecode2 = 0 ;
12253 PyObject * obj0 = 0 ;
12254 PyObject * obj1 = 0 ;
12255 char * kwnames[] = {
12256 (char *) "self",(char *) "key", NULL
12257 };
12258
12259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12261 if (!SWIG_IsOK(res1)) {
12262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12263 }
12264 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12265 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12266 if (!SWIG_IsOK(ecode2)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12268 }
12269 arg2 = static_cast< unsigned long >(val2);
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj = 0;
12285 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12286 byte arg2 ;
12287 byte arg3 ;
12288 byte arg4 ;
12289 unsigned long result;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 unsigned char val2 ;
12293 int ecode2 = 0 ;
12294 unsigned char val3 ;
12295 int ecode3 = 0 ;
12296 unsigned char val4 ;
12297 int ecode4 = 0 ;
12298 PyObject * obj0 = 0 ;
12299 PyObject * obj1 = 0 ;
12300 PyObject * obj2 = 0 ;
12301 PyObject * obj3 = 0 ;
12302 char * kwnames[] = {
12303 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12304 };
12305
12306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12308 if (!SWIG_IsOK(res1)) {
12309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12310 }
12311 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12312 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12313 if (!SWIG_IsOK(ecode2)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12315 }
12316 arg2 = static_cast< byte >(val2);
12317 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12318 if (!SWIG_IsOK(ecode3)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12320 }
12321 arg3 = static_cast< byte >(val3);
12322 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12323 if (!SWIG_IsOK(ecode4)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12325 }
12326 arg4 = static_cast< byte >(val4);
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12330 wxPyEndAllowThreads(__tstate);
12331 if (PyErr_Occurred()) SWIG_fail;
12332 }
12333 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12334 return resultobj;
12335 fail:
12336 return NULL;
12337 }
12338
12339
12340 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj = 0;
12342 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12343 wxColour *arg2 = 0 ;
12344 unsigned long result;
12345 void *argp1 = 0 ;
12346 int res1 = 0 ;
12347 wxColour temp2 ;
12348 PyObject * obj0 = 0 ;
12349 PyObject * obj1 = 0 ;
12350 char * kwnames[] = {
12351 (char *) "self",(char *) "colour", NULL
12352 };
12353
12354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12356 if (!SWIG_IsOK(res1)) {
12357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12358 }
12359 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12360 {
12361 arg2 = &temp2;
12362 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12363 }
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378 PyObject *obj;
12379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12380 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12381 return SWIG_Py_Void();
12382 }
12383
12384 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12385 return SWIG_Python_InitShadowInstance(args);
12386 }
12387
12388 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj = 0;
12390 byte arg1 = (byte) 0 ;
12391 byte arg2 = (byte) 0 ;
12392 byte arg3 = (byte) 0 ;
12393 wxImage_RGBValue *result = 0 ;
12394 unsigned char val1 ;
12395 int ecode1 = 0 ;
12396 unsigned char val2 ;
12397 int ecode2 = 0 ;
12398 unsigned char val3 ;
12399 int ecode3 = 0 ;
12400 PyObject * obj0 = 0 ;
12401 PyObject * obj1 = 0 ;
12402 PyObject * obj2 = 0 ;
12403 char * kwnames[] = {
12404 (char *) "r",(char *) "g",(char *) "b", NULL
12405 };
12406
12407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12408 if (obj0) {
12409 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12410 if (!SWIG_IsOK(ecode1)) {
12411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12412 }
12413 arg1 = static_cast< byte >(val1);
12414 }
12415 if (obj1) {
12416 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12417 if (!SWIG_IsOK(ecode2)) {
12418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12419 }
12420 arg2 = static_cast< byte >(val2);
12421 }
12422 if (obj2) {
12423 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12424 if (!SWIG_IsOK(ecode3)) {
12425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12426 }
12427 arg3 = static_cast< byte >(val3);
12428 }
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 PyObject *resultobj = 0;
12444 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12445 byte arg2 ;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 unsigned char val2 ;
12449 int ecode2 = 0 ;
12450 PyObject *swig_obj[2] ;
12451
12452 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12454 if (!SWIG_IsOK(res1)) {
12455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12456 }
12457 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12458 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12459 if (!SWIG_IsOK(ecode2)) {
12460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12461 }
12462 arg2 = static_cast< byte >(val2);
12463 if (arg1) (arg1)->red = arg2;
12464
12465 resultobj = SWIG_Py_Void();
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12473 PyObject *resultobj = 0;
12474 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12475 byte result;
12476 void *argp1 = 0 ;
12477 int res1 = 0 ;
12478 PyObject *swig_obj[1] ;
12479
12480 if (!args) SWIG_fail;
12481 swig_obj[0] = args;
12482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12485 }
12486 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12487 result = (byte) ((arg1)->red);
12488 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12489 return resultobj;
12490 fail:
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *resultobj = 0;
12497 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12498 byte arg2 ;
12499 void *argp1 = 0 ;
12500 int res1 = 0 ;
12501 unsigned char val2 ;
12502 int ecode2 = 0 ;
12503 PyObject *swig_obj[2] ;
12504
12505 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12507 if (!SWIG_IsOK(res1)) {
12508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12509 }
12510 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12511 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12512 if (!SWIG_IsOK(ecode2)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12514 }
12515 arg2 = static_cast< byte >(val2);
12516 if (arg1) (arg1)->green = arg2;
12517
12518 resultobj = SWIG_Py_Void();
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12526 PyObject *resultobj = 0;
12527 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12528 byte result;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 PyObject *swig_obj[1] ;
12532
12533 if (!args) SWIG_fail;
12534 swig_obj[0] = args;
12535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12538 }
12539 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12540 result = (byte) ((arg1)->green);
12541 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12549 PyObject *resultobj = 0;
12550 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12551 byte arg2 ;
12552 void *argp1 = 0 ;
12553 int res1 = 0 ;
12554 unsigned char val2 ;
12555 int ecode2 = 0 ;
12556 PyObject *swig_obj[2] ;
12557
12558 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12560 if (!SWIG_IsOK(res1)) {
12561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12562 }
12563 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12564 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12565 if (!SWIG_IsOK(ecode2)) {
12566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12567 }
12568 arg2 = static_cast< byte >(val2);
12569 if (arg1) (arg1)->blue = arg2;
12570
12571 resultobj = SWIG_Py_Void();
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12579 PyObject *resultobj = 0;
12580 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12581 byte result;
12582 void *argp1 = 0 ;
12583 int res1 = 0 ;
12584 PyObject *swig_obj[1] ;
12585
12586 if (!args) SWIG_fail;
12587 swig_obj[0] = args;
12588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12589 if (!SWIG_IsOK(res1)) {
12590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12591 }
12592 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12593 result = (byte) ((arg1)->blue);
12594 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12602 PyObject *obj;
12603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12604 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12605 return SWIG_Py_Void();
12606 }
12607
12608 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12609 return SWIG_Python_InitShadowInstance(args);
12610 }
12611
12612 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj = 0;
12614 double arg1 = (double) 0.0 ;
12615 double arg2 = (double) 0.0 ;
12616 double arg3 = (double) 0.0 ;
12617 wxImage_HSVValue *result = 0 ;
12618 double val1 ;
12619 int ecode1 = 0 ;
12620 double val2 ;
12621 int ecode2 = 0 ;
12622 double val3 ;
12623 int ecode3 = 0 ;
12624 PyObject * obj0 = 0 ;
12625 PyObject * obj1 = 0 ;
12626 PyObject * obj2 = 0 ;
12627 char * kwnames[] = {
12628 (char *) "h",(char *) "s",(char *) "v", NULL
12629 };
12630
12631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12632 if (obj0) {
12633 ecode1 = SWIG_AsVal_double(obj0, &val1);
12634 if (!SWIG_IsOK(ecode1)) {
12635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12636 }
12637 arg1 = static_cast< double >(val1);
12638 }
12639 if (obj1) {
12640 ecode2 = SWIG_AsVal_double(obj1, &val2);
12641 if (!SWIG_IsOK(ecode2)) {
12642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12643 }
12644 arg2 = static_cast< double >(val2);
12645 }
12646 if (obj2) {
12647 ecode3 = SWIG_AsVal_double(obj2, &val3);
12648 if (!SWIG_IsOK(ecode3)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12650 }
12651 arg3 = static_cast< double >(val3);
12652 }
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12667 PyObject *resultobj = 0;
12668 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12669 double arg2 ;
12670 void *argp1 = 0 ;
12671 int res1 = 0 ;
12672 double val2 ;
12673 int ecode2 = 0 ;
12674 PyObject *swig_obj[2] ;
12675
12676 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12678 if (!SWIG_IsOK(res1)) {
12679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12680 }
12681 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12682 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12683 if (!SWIG_IsOK(ecode2)) {
12684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12685 }
12686 arg2 = static_cast< double >(val2);
12687 if (arg1) (arg1)->hue = arg2;
12688
12689 resultobj = SWIG_Py_Void();
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12697 PyObject *resultobj = 0;
12698 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12699 double result;
12700 void *argp1 = 0 ;
12701 int res1 = 0 ;
12702 PyObject *swig_obj[1] ;
12703
12704 if (!args) SWIG_fail;
12705 swig_obj[0] = args;
12706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12707 if (!SWIG_IsOK(res1)) {
12708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12709 }
12710 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12711 result = (double) ((arg1)->hue);
12712 resultobj = SWIG_From_double(static_cast< double >(result));
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 PyObject *resultobj = 0;
12721 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12722 double arg2 ;
12723 void *argp1 = 0 ;
12724 int res1 = 0 ;
12725 double val2 ;
12726 int ecode2 = 0 ;
12727 PyObject *swig_obj[2] ;
12728
12729 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12731 if (!SWIG_IsOK(res1)) {
12732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12733 }
12734 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12735 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12736 if (!SWIG_IsOK(ecode2)) {
12737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12738 }
12739 arg2 = static_cast< double >(val2);
12740 if (arg1) (arg1)->saturation = arg2;
12741
12742 resultobj = SWIG_Py_Void();
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12750 PyObject *resultobj = 0;
12751 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12752 double result;
12753 void *argp1 = 0 ;
12754 int res1 = 0 ;
12755 PyObject *swig_obj[1] ;
12756
12757 if (!args) SWIG_fail;
12758 swig_obj[0] = args;
12759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12762 }
12763 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12764 result = (double) ((arg1)->saturation);
12765 resultobj = SWIG_From_double(static_cast< double >(result));
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12773 PyObject *resultobj = 0;
12774 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12775 double arg2 ;
12776 void *argp1 = 0 ;
12777 int res1 = 0 ;
12778 double val2 ;
12779 int ecode2 = 0 ;
12780 PyObject *swig_obj[2] ;
12781
12782 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12784 if (!SWIG_IsOK(res1)) {
12785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12786 }
12787 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12788 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12789 if (!SWIG_IsOK(ecode2)) {
12790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12791 }
12792 arg2 = static_cast< double >(val2);
12793 if (arg1) (arg1)->value = arg2;
12794
12795 resultobj = SWIG_Py_Void();
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12803 PyObject *resultobj = 0;
12804 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12805 double result;
12806 void *argp1 = 0 ;
12807 int res1 = 0 ;
12808 PyObject *swig_obj[1] ;
12809
12810 if (!args) SWIG_fail;
12811 swig_obj[0] = args;
12812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12815 }
12816 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12817 result = (double) ((arg1)->value);
12818 resultobj = SWIG_From_double(static_cast< double >(result));
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *obj;
12827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12828 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12829 return SWIG_Py_Void();
12830 }
12831
12832 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 return SWIG_Python_InitShadowInstance(args);
12834 }
12835
12836 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12837 PyObject *resultobj = 0;
12838 wxString *arg1 = 0 ;
12839 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12840 int arg3 = (int) -1 ;
12841 wxImage *result = 0 ;
12842 bool temp1 = false ;
12843 long val2 ;
12844 int ecode2 = 0 ;
12845 int val3 ;
12846 int ecode3 = 0 ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 char * kwnames[] = {
12851 (char *) "name",(char *) "type",(char *) "index", NULL
12852 };
12853
12854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12855 {
12856 arg1 = wxString_in_helper(obj0);
12857 if (arg1 == NULL) SWIG_fail;
12858 temp1 = true;
12859 }
12860 if (obj1) {
12861 ecode2 = SWIG_AsVal_long(obj1, &val2);
12862 if (!SWIG_IsOK(ecode2)) {
12863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12864 }
12865 arg2 = static_cast< long >(val2);
12866 }
12867 if (obj2) {
12868 ecode3 = SWIG_AsVal_int(obj2, &val3);
12869 if (!SWIG_IsOK(ecode3)) {
12870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12871 }
12872 arg3 = static_cast< int >(val3);
12873 }
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12881 {
12882 if (temp1)
12883 delete arg1;
12884 }
12885 return resultobj;
12886 fail:
12887 {
12888 if (temp1)
12889 delete arg1;
12890 }
12891 return NULL;
12892 }
12893
12894
12895 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12896 PyObject *resultobj = 0;
12897 wxImage *arg1 = (wxImage *) 0 ;
12898 void *argp1 = 0 ;
12899 int res1 = 0 ;
12900 PyObject *swig_obj[1] ;
12901
12902 if (!args) SWIG_fail;
12903 swig_obj[0] = args;
12904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12905 if (!SWIG_IsOK(res1)) {
12906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12907 }
12908 arg1 = reinterpret_cast< wxImage * >(argp1);
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 delete arg1;
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 resultobj = SWIG_Py_Void();
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj = 0;
12925 wxString *arg1 = 0 ;
12926 wxString *arg2 = 0 ;
12927 int arg3 = (int) -1 ;
12928 wxImage *result = 0 ;
12929 bool temp1 = false ;
12930 bool temp2 = false ;
12931 int val3 ;
12932 int ecode3 = 0 ;
12933 PyObject * obj0 = 0 ;
12934 PyObject * obj1 = 0 ;
12935 PyObject * obj2 = 0 ;
12936 char * kwnames[] = {
12937 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12938 };
12939
12940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12941 {
12942 arg1 = wxString_in_helper(obj0);
12943 if (arg1 == NULL) SWIG_fail;
12944 temp1 = true;
12945 }
12946 {
12947 arg2 = wxString_in_helper(obj1);
12948 if (arg2 == NULL) SWIG_fail;
12949 temp2 = true;
12950 }
12951 if (obj2) {
12952 ecode3 = SWIG_AsVal_int(obj2, &val3);
12953 if (!SWIG_IsOK(ecode3)) {
12954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12955 }
12956 arg3 = static_cast< int >(val3);
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12965 {
12966 if (temp1)
12967 delete arg1;
12968 }
12969 {
12970 if (temp2)
12971 delete arg2;
12972 }
12973 return resultobj;
12974 fail:
12975 {
12976 if (temp1)
12977 delete arg1;
12978 }
12979 {
12980 if (temp2)
12981 delete arg2;
12982 }
12983 return NULL;
12984 }
12985
12986
12987 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12988 PyObject *resultobj = 0;
12989 wxInputStream *arg1 = 0 ;
12990 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12991 int arg3 = (int) -1 ;
12992 wxImage *result = 0 ;
12993 wxPyInputStream *temp1 ;
12994 bool created1 ;
12995 long val2 ;
12996 int ecode2 = 0 ;
12997 int val3 ;
12998 int ecode3 = 0 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 PyObject * obj2 = 0 ;
13002 char * kwnames[] = {
13003 (char *) "stream",(char *) "type",(char *) "index", NULL
13004 };
13005
13006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13007 {
13008 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13009 arg1 = temp1->m_wxis;
13010 created1 = false;
13011 } else {
13012 PyErr_Clear(); // clear the failure of the wxPyConvert above
13013 arg1 = wxPyCBInputStream_create(obj0, false);
13014 if (arg1 == NULL) {
13015 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13016 SWIG_fail;
13017 }
13018 created1 = true;
13019 }
13020 }
13021 if (obj1) {
13022 ecode2 = SWIG_AsVal_long(obj1, &val2);
13023 if (!SWIG_IsOK(ecode2)) {
13024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13025 }
13026 arg2 = static_cast< long >(val2);
13027 }
13028 if (obj2) {
13029 ecode3 = SWIG_AsVal_int(obj2, &val3);
13030 if (!SWIG_IsOK(ecode3)) {
13031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13032 }
13033 arg3 = static_cast< int >(val3);
13034 }
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13038 wxPyEndAllowThreads(__tstate);
13039 if (PyErr_Occurred()) SWIG_fail;
13040 }
13041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13042 {
13043 if (created1) delete arg1;
13044 }
13045 return resultobj;
13046 fail:
13047 {
13048 if (created1) delete arg1;
13049 }
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxInputStream *arg1 = 0 ;
13057 wxString *arg2 = 0 ;
13058 int arg3 = (int) -1 ;
13059 wxImage *result = 0 ;
13060 wxPyInputStream *temp1 ;
13061 bool created1 ;
13062 bool temp2 = false ;
13063 int val3 ;
13064 int ecode3 = 0 ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 PyObject * obj2 = 0 ;
13068 char * kwnames[] = {
13069 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13070 };
13071
13072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13073 {
13074 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13075 arg1 = temp1->m_wxis;
13076 created1 = false;
13077 } else {
13078 PyErr_Clear(); // clear the failure of the wxPyConvert above
13079 arg1 = wxPyCBInputStream_create(obj0, false);
13080 if (arg1 == NULL) {
13081 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13082 SWIG_fail;
13083 }
13084 created1 = true;
13085 }
13086 }
13087 {
13088 arg2 = wxString_in_helper(obj1);
13089 if (arg2 == NULL) SWIG_fail;
13090 temp2 = true;
13091 }
13092 if (obj2) {
13093 ecode3 = SWIG_AsVal_int(obj2, &val3);
13094 if (!SWIG_IsOK(ecode3)) {
13095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13096 }
13097 arg3 = static_cast< int >(val3);
13098 }
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13106 {
13107 if (created1) delete arg1;
13108 }
13109 {
13110 if (temp2)
13111 delete arg2;
13112 }
13113 return resultobj;
13114 fail:
13115 {
13116 if (created1) delete arg1;
13117 }
13118 {
13119 if (temp2)
13120 delete arg2;
13121 }
13122 return NULL;
13123 }
13124
13125
13126 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13127 PyObject *resultobj = 0;
13128 int arg1 = (int) 0 ;
13129 int arg2 = (int) 0 ;
13130 bool arg3 = (bool) true ;
13131 wxImage *result = 0 ;
13132 int val1 ;
13133 int ecode1 = 0 ;
13134 int val2 ;
13135 int ecode2 = 0 ;
13136 bool val3 ;
13137 int ecode3 = 0 ;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 PyObject * obj2 = 0 ;
13141 char * kwnames[] = {
13142 (char *) "width",(char *) "height",(char *) "clear", NULL
13143 };
13144
13145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13146 if (obj0) {
13147 ecode1 = SWIG_AsVal_int(obj0, &val1);
13148 if (!SWIG_IsOK(ecode1)) {
13149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13150 }
13151 arg1 = static_cast< int >(val1);
13152 }
13153 if (obj1) {
13154 ecode2 = SWIG_AsVal_int(obj1, &val2);
13155 if (!SWIG_IsOK(ecode2)) {
13156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13157 }
13158 arg2 = static_cast< int >(val2);
13159 }
13160 if (obj2) {
13161 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13162 if (!SWIG_IsOK(ecode3)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13164 }
13165 arg3 = static_cast< bool >(val3);
13166 }
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13170 wxPyEndAllowThreads(__tstate);
13171 if (PyErr_Occurred()) SWIG_fail;
13172 }
13173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13174 return resultobj;
13175 fail:
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxBitmap *arg1 = 0 ;
13183 wxImage *result = 0 ;
13184 void *argp1 = 0 ;
13185 int res1 = 0 ;
13186 PyObject * obj0 = 0 ;
13187 char * kwnames[] = {
13188 (char *) "bitmap", NULL
13189 };
13190
13191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13192 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13193 if (!SWIG_IsOK(res1)) {
13194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13195 }
13196 if (!argp1) {
13197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13198 }
13199 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13200 {
13201 if (!wxPyCheckForApp()) SWIG_fail;
13202 PyThreadState* __tstate = wxPyBeginAllowThreads();
13203 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = 0;
13216 int arg1 ;
13217 int arg2 ;
13218 buffer arg3 ;
13219 int arg4 ;
13220 wxImage *result = 0 ;
13221 int val1 ;
13222 int ecode1 = 0 ;
13223 int val2 ;
13224 int ecode2 = 0 ;
13225 PyObject * obj0 = 0 ;
13226 PyObject * obj1 = 0 ;
13227 PyObject * obj2 = 0 ;
13228 char * kwnames[] = {
13229 (char *) "width",(char *) "height",(char *) "data", NULL
13230 };
13231
13232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13233 ecode1 = SWIG_AsVal_int(obj0, &val1);
13234 if (!SWIG_IsOK(ecode1)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13236 }
13237 arg1 = static_cast< int >(val1);
13238 ecode2 = SWIG_AsVal_int(obj1, &val2);
13239 if (!SWIG_IsOK(ecode2)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13241 }
13242 arg2 = static_cast< int >(val2);
13243 {
13244 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13245 }
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj = 0;
13261 int arg1 ;
13262 int arg2 ;
13263 buffer arg3 ;
13264 int arg4 ;
13265 buffer arg5 ;
13266 int arg6 ;
13267 wxImage *result = 0 ;
13268 int val1 ;
13269 int ecode1 = 0 ;
13270 int val2 ;
13271 int ecode2 = 0 ;
13272 PyObject * obj0 = 0 ;
13273 PyObject * obj1 = 0 ;
13274 PyObject * obj2 = 0 ;
13275 PyObject * obj3 = 0 ;
13276 char * kwnames[] = {
13277 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13278 };
13279
13280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13281 ecode1 = SWIG_AsVal_int(obj0, &val1);
13282 if (!SWIG_IsOK(ecode1)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13284 }
13285 arg1 = static_cast< int >(val1);
13286 ecode2 = SWIG_AsVal_int(obj1, &val2);
13287 if (!SWIG_IsOK(ecode2)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13289 }
13290 arg2 = static_cast< int >(val2);
13291 {
13292 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13293 }
13294 {
13295 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = 0;
13312 wxImage *arg1 = (wxImage *) 0 ;
13313 int arg2 ;
13314 int arg3 ;
13315 bool arg4 = (bool) true ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 int val2 ;
13319 int ecode2 = 0 ;
13320 int val3 ;
13321 int ecode3 = 0 ;
13322 bool val4 ;
13323 int ecode4 = 0 ;
13324 PyObject * obj0 = 0 ;
13325 PyObject * obj1 = 0 ;
13326 PyObject * obj2 = 0 ;
13327 PyObject * obj3 = 0 ;
13328 char * kwnames[] = {
13329 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13330 };
13331
13332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13334 if (!SWIG_IsOK(res1)) {
13335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13336 }
13337 arg1 = reinterpret_cast< wxImage * >(argp1);
13338 ecode2 = SWIG_AsVal_int(obj1, &val2);
13339 if (!SWIG_IsOK(ecode2)) {
13340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13341 }
13342 arg2 = static_cast< int >(val2);
13343 ecode3 = SWIG_AsVal_int(obj2, &val3);
13344 if (!SWIG_IsOK(ecode3)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13346 }
13347 arg3 = static_cast< int >(val3);
13348 if (obj3) {
13349 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13350 if (!SWIG_IsOK(ecode4)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13352 }
13353 arg4 = static_cast< bool >(val4);
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 (arg1)->Create(arg2,arg3,arg4);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_Py_Void();
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13369 PyObject *resultobj = 0;
13370 wxImage *arg1 = (wxImage *) 0 ;
13371 void *argp1 = 0 ;
13372 int res1 = 0 ;
13373 PyObject *swig_obj[1] ;
13374
13375 if (!args) SWIG_fail;
13376 swig_obj[0] = args;
13377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13378 if (!SWIG_IsOK(res1)) {
13379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13380 }
13381 arg1 = reinterpret_cast< wxImage * >(argp1);
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 (arg1)->Destroy();
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 resultobj = SWIG_Py_Void();
13389 return resultobj;
13390 fail:
13391 return NULL;
13392 }
13393
13394
13395 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13396 PyObject *resultobj = 0;
13397 wxImage *arg1 = (wxImage *) 0 ;
13398 int arg2 ;
13399 int arg3 ;
13400 SwigValueWrapper<wxImage > result;
13401 void *argp1 = 0 ;
13402 int res1 = 0 ;
13403 int val2 ;
13404 int ecode2 = 0 ;
13405 int val3 ;
13406 int ecode3 = 0 ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 PyObject * obj2 = 0 ;
13410 char * kwnames[] = {
13411 (char *) "self",(char *) "width",(char *) "height", NULL
13412 };
13413
13414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13416 if (!SWIG_IsOK(res1)) {
13417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13418 }
13419 arg1 = reinterpret_cast< wxImage * >(argp1);
13420 ecode2 = SWIG_AsVal_int(obj1, &val2);
13421 if (!SWIG_IsOK(ecode2)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13423 }
13424 arg2 = static_cast< int >(val2);
13425 ecode3 = SWIG_AsVal_int(obj2, &val3);
13426 if (!SWIG_IsOK(ecode3)) {
13427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13428 }
13429 arg3 = static_cast< int >(val3);
13430 {
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 result = (arg1)->Scale(arg2,arg3);
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13444 PyObject *resultobj = 0;
13445 wxImage *arg1 = (wxImage *) 0 ;
13446 int arg2 ;
13447 int arg3 ;
13448 SwigValueWrapper<wxImage > result;
13449 void *argp1 = 0 ;
13450 int res1 = 0 ;
13451 int val2 ;
13452 int ecode2 = 0 ;
13453 int val3 ;
13454 int ecode3 = 0 ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 PyObject * obj2 = 0 ;
13458 char * kwnames[] = {
13459 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13460 };
13461
13462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13464 if (!SWIG_IsOK(res1)) {
13465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13466 }
13467 arg1 = reinterpret_cast< wxImage * >(argp1);
13468 ecode2 = SWIG_AsVal_int(obj1, &val2);
13469 if (!SWIG_IsOK(ecode2)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13471 }
13472 arg2 = static_cast< int >(val2);
13473 ecode3 = SWIG_AsVal_int(obj2, &val3);
13474 if (!SWIG_IsOK(ecode3)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13476 }
13477 arg3 = static_cast< int >(val3);
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj = 0;
13493 wxImage *arg1 = (wxImage *) 0 ;
13494 int arg2 ;
13495 int arg3 ;
13496 wxImage *result = 0 ;
13497 void *argp1 = 0 ;
13498 int res1 = 0 ;
13499 int val2 ;
13500 int ecode2 = 0 ;
13501 int val3 ;
13502 int ecode3 = 0 ;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 PyObject * obj2 = 0 ;
13506 char * kwnames[] = {
13507 (char *) "self",(char *) "width",(char *) "height", NULL
13508 };
13509
13510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13512 if (!SWIG_IsOK(res1)) {
13513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13514 }
13515 arg1 = reinterpret_cast< wxImage * >(argp1);
13516 ecode2 = SWIG_AsVal_int(obj1, &val2);
13517 if (!SWIG_IsOK(ecode2)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13519 }
13520 arg2 = static_cast< int >(val2);
13521 ecode3 = SWIG_AsVal_int(obj2, &val3);
13522 if (!SWIG_IsOK(ecode3)) {
13523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13524 }
13525 arg3 = static_cast< int >(val3);
13526 {
13527 PyThreadState* __tstate = wxPyBeginAllowThreads();
13528 {
13529 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13530 result = (wxImage *) &_result_ref;
13531 }
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13536 return resultobj;
13537 fail:
13538 return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj = 0;
13544 wxImage *arg1 = (wxImage *) 0 ;
13545 wxSize *arg2 = 0 ;
13546 wxPoint *arg3 = 0 ;
13547 int arg4 = (int) -1 ;
13548 int arg5 = (int) -1 ;
13549 int arg6 = (int) -1 ;
13550 wxImage *result = 0 ;
13551 void *argp1 = 0 ;
13552 int res1 = 0 ;
13553 wxSize temp2 ;
13554 wxPoint temp3 ;
13555 int val4 ;
13556 int ecode4 = 0 ;
13557 int val5 ;
13558 int ecode5 = 0 ;
13559 int val6 ;
13560 int ecode6 = 0 ;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 PyObject * obj2 = 0 ;
13564 PyObject * obj3 = 0 ;
13565 PyObject * obj4 = 0 ;
13566 PyObject * obj5 = 0 ;
13567 char * kwnames[] = {
13568 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13569 };
13570
13571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13575 }
13576 arg1 = reinterpret_cast< wxImage * >(argp1);
13577 {
13578 arg2 = &temp2;
13579 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13580 }
13581 {
13582 arg3 = &temp3;
13583 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13584 }
13585 if (obj3) {
13586 ecode4 = SWIG_AsVal_int(obj3, &val4);
13587 if (!SWIG_IsOK(ecode4)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13589 }
13590 arg4 = static_cast< int >(val4);
13591 }
13592 if (obj4) {
13593 ecode5 = SWIG_AsVal_int(obj4, &val5);
13594 if (!SWIG_IsOK(ecode5)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13596 }
13597 arg5 = static_cast< int >(val5);
13598 }
13599 if (obj5) {
13600 ecode6 = SWIG_AsVal_int(obj5, &val6);
13601 if (!SWIG_IsOK(ecode6)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13603 }
13604 arg6 = static_cast< int >(val6);
13605 }
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 {
13609 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13610 result = (wxImage *) &_result_ref;
13611 }
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 int arg2 ;
13626 int arg3 ;
13627 byte arg4 ;
13628 byte arg5 ;
13629 byte arg6 ;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 int val2 ;
13633 int ecode2 = 0 ;
13634 int val3 ;
13635 int ecode3 = 0 ;
13636 unsigned char val4 ;
13637 int ecode4 = 0 ;
13638 unsigned char val5 ;
13639 int ecode5 = 0 ;
13640 unsigned char val6 ;
13641 int ecode6 = 0 ;
13642 PyObject * obj0 = 0 ;
13643 PyObject * obj1 = 0 ;
13644 PyObject * obj2 = 0 ;
13645 PyObject * obj3 = 0 ;
13646 PyObject * obj4 = 0 ;
13647 PyObject * obj5 = 0 ;
13648 char * kwnames[] = {
13649 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13650 };
13651
13652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13654 if (!SWIG_IsOK(res1)) {
13655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13656 }
13657 arg1 = reinterpret_cast< wxImage * >(argp1);
13658 ecode2 = SWIG_AsVal_int(obj1, &val2);
13659 if (!SWIG_IsOK(ecode2)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13661 }
13662 arg2 = static_cast< int >(val2);
13663 ecode3 = SWIG_AsVal_int(obj2, &val3);
13664 if (!SWIG_IsOK(ecode3)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13666 }
13667 arg3 = static_cast< int >(val3);
13668 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13669 if (!SWIG_IsOK(ecode4)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13671 }
13672 arg4 = static_cast< byte >(val4);
13673 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13674 if (!SWIG_IsOK(ecode5)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13676 }
13677 arg5 = static_cast< byte >(val5);
13678 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13679 if (!SWIG_IsOK(ecode6)) {
13680 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13681 }
13682 arg6 = static_cast< byte >(val6);
13683 {
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_Py_Void();
13690 return resultobj;
13691 fail:
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 wxImage *arg1 = (wxImage *) 0 ;
13699 wxRect *arg2 = 0 ;
13700 byte arg3 ;
13701 byte arg4 ;
13702 byte arg5 ;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 wxRect temp2 ;
13706 unsigned char val3 ;
13707 int ecode3 = 0 ;
13708 unsigned char val4 ;
13709 int ecode4 = 0 ;
13710 unsigned char val5 ;
13711 int ecode5 = 0 ;
13712 PyObject * obj0 = 0 ;
13713 PyObject * obj1 = 0 ;
13714 PyObject * obj2 = 0 ;
13715 PyObject * obj3 = 0 ;
13716 PyObject * obj4 = 0 ;
13717 char * kwnames[] = {
13718 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13719 };
13720
13721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13723 if (!SWIG_IsOK(res1)) {
13724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13725 }
13726 arg1 = reinterpret_cast< wxImage * >(argp1);
13727 {
13728 arg2 = &temp2;
13729 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13730 }
13731 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13732 if (!SWIG_IsOK(ecode3)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13734 }
13735 arg3 = static_cast< byte >(val3);
13736 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13737 if (!SWIG_IsOK(ecode4)) {
13738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13739 }
13740 arg4 = static_cast< byte >(val4);
13741 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13742 if (!SWIG_IsOK(ecode5)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13744 }
13745 arg5 = static_cast< byte >(val5);
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13749 wxPyEndAllowThreads(__tstate);
13750 if (PyErr_Occurred()) SWIG_fail;
13751 }
13752 resultobj = SWIG_Py_Void();
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 wxImage *arg1 = (wxImage *) 0 ;
13762 int arg2 ;
13763 int arg3 ;
13764 byte result;
13765 void *argp1 = 0 ;
13766 int res1 = 0 ;
13767 int val2 ;
13768 int ecode2 = 0 ;
13769 int val3 ;
13770 int ecode3 = 0 ;
13771 PyObject * obj0 = 0 ;
13772 PyObject * obj1 = 0 ;
13773 PyObject * obj2 = 0 ;
13774 char * kwnames[] = {
13775 (char *) "self",(char *) "x",(char *) "y", NULL
13776 };
13777
13778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13780 if (!SWIG_IsOK(res1)) {
13781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13782 }
13783 arg1 = reinterpret_cast< wxImage * >(argp1);
13784 ecode2 = SWIG_AsVal_int(obj1, &val2);
13785 if (!SWIG_IsOK(ecode2)) {
13786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13787 }
13788 arg2 = static_cast< int >(val2);
13789 ecode3 = SWIG_AsVal_int(obj2, &val3);
13790 if (!SWIG_IsOK(ecode3)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13792 }
13793 arg3 = static_cast< int >(val3);
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 result = (byte)(arg1)->GetRed(arg2,arg3);
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13801 return resultobj;
13802 fail:
13803 return NULL;
13804 }
13805
13806
13807 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13808 PyObject *resultobj = 0;
13809 wxImage *arg1 = (wxImage *) 0 ;
13810 int arg2 ;
13811 int arg3 ;
13812 byte result;
13813 void *argp1 = 0 ;
13814 int res1 = 0 ;
13815 int val2 ;
13816 int ecode2 = 0 ;
13817 int val3 ;
13818 int ecode3 = 0 ;
13819 PyObject * obj0 = 0 ;
13820 PyObject * obj1 = 0 ;
13821 PyObject * obj2 = 0 ;
13822 char * kwnames[] = {
13823 (char *) "self",(char *) "x",(char *) "y", NULL
13824 };
13825
13826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13828 if (!SWIG_IsOK(res1)) {
13829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13830 }
13831 arg1 = reinterpret_cast< wxImage * >(argp1);
13832 ecode2 = SWIG_AsVal_int(obj1, &val2);
13833 if (!SWIG_IsOK(ecode2)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13835 }
13836 arg2 = static_cast< int >(val2);
13837 ecode3 = SWIG_AsVal_int(obj2, &val3);
13838 if (!SWIG_IsOK(ecode3)) {
13839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13840 }
13841 arg3 = static_cast< int >(val3);
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 result = (byte)(arg1)->GetGreen(arg2,arg3);
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj = 0;
13857 wxImage *arg1 = (wxImage *) 0 ;
13858 int arg2 ;
13859 int arg3 ;
13860 byte result;
13861 void *argp1 = 0 ;
13862 int res1 = 0 ;
13863 int val2 ;
13864 int ecode2 = 0 ;
13865 int val3 ;
13866 int ecode3 = 0 ;
13867 PyObject * obj0 = 0 ;
13868 PyObject * obj1 = 0 ;
13869 PyObject * obj2 = 0 ;
13870 char * kwnames[] = {
13871 (char *) "self",(char *) "x",(char *) "y", NULL
13872 };
13873
13874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13876 if (!SWIG_IsOK(res1)) {
13877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13878 }
13879 arg1 = reinterpret_cast< wxImage * >(argp1);
13880 ecode2 = SWIG_AsVal_int(obj1, &val2);
13881 if (!SWIG_IsOK(ecode2)) {
13882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13883 }
13884 arg2 = static_cast< int >(val2);
13885 ecode3 = SWIG_AsVal_int(obj2, &val3);
13886 if (!SWIG_IsOK(ecode3)) {
13887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13888 }
13889 arg3 = static_cast< int >(val3);
13890 {
13891 PyThreadState* __tstate = wxPyBeginAllowThreads();
13892 result = (byte)(arg1)->GetBlue(arg2,arg3);
13893 wxPyEndAllowThreads(__tstate);
13894 if (PyErr_Occurred()) SWIG_fail;
13895 }
13896 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13897 return resultobj;
13898 fail:
13899 return NULL;
13900 }
13901
13902
13903 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13904 PyObject *resultobj = 0;
13905 wxImage *arg1 = (wxImage *) 0 ;
13906 int arg2 ;
13907 int arg3 ;
13908 byte arg4 ;
13909 void *argp1 = 0 ;
13910 int res1 = 0 ;
13911 int val2 ;
13912 int ecode2 = 0 ;
13913 int val3 ;
13914 int ecode3 = 0 ;
13915 unsigned char val4 ;
13916 int ecode4 = 0 ;
13917 PyObject * obj0 = 0 ;
13918 PyObject * obj1 = 0 ;
13919 PyObject * obj2 = 0 ;
13920 PyObject * obj3 = 0 ;
13921 char * kwnames[] = {
13922 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13923 };
13924
13925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13927 if (!SWIG_IsOK(res1)) {
13928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13929 }
13930 arg1 = reinterpret_cast< wxImage * >(argp1);
13931 ecode2 = SWIG_AsVal_int(obj1, &val2);
13932 if (!SWIG_IsOK(ecode2)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13934 }
13935 arg2 = static_cast< int >(val2);
13936 ecode3 = SWIG_AsVal_int(obj2, &val3);
13937 if (!SWIG_IsOK(ecode3)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13939 }
13940 arg3 = static_cast< int >(val3);
13941 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13942 if (!SWIG_IsOK(ecode4)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13944 }
13945 arg4 = static_cast< byte >(val4);
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 (arg1)->SetAlpha(arg2,arg3,arg4);
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13960 PyObject *resultobj = 0;
13961 wxImage *arg1 = (wxImage *) 0 ;
13962 int arg2 ;
13963 int arg3 ;
13964 byte result;
13965 void *argp1 = 0 ;
13966 int res1 = 0 ;
13967 int val2 ;
13968 int ecode2 = 0 ;
13969 int val3 ;
13970 int ecode3 = 0 ;
13971 PyObject * obj0 = 0 ;
13972 PyObject * obj1 = 0 ;
13973 PyObject * obj2 = 0 ;
13974 char * kwnames[] = {
13975 (char *) "self",(char *) "x",(char *) "y", NULL
13976 };
13977
13978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13980 if (!SWIG_IsOK(res1)) {
13981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13982 }
13983 arg1 = reinterpret_cast< wxImage * >(argp1);
13984 ecode2 = SWIG_AsVal_int(obj1, &val2);
13985 if (!SWIG_IsOK(ecode2)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13987 }
13988 arg2 = static_cast< int >(val2);
13989 ecode3 = SWIG_AsVal_int(obj2, &val3);
13990 if (!SWIG_IsOK(ecode3)) {
13991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13992 }
13993 arg3 = static_cast< int >(val3);
13994 {
13995 PyThreadState* __tstate = wxPyBeginAllowThreads();
13996 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13997 wxPyEndAllowThreads(__tstate);
13998 if (PyErr_Occurred()) SWIG_fail;
13999 }
14000 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14001 return resultobj;
14002 fail:
14003 return NULL;
14004 }
14005
14006
14007 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14008 PyObject *resultobj = 0;
14009 wxImage *arg1 = (wxImage *) 0 ;
14010 bool result;
14011 void *argp1 = 0 ;
14012 int res1 = 0 ;
14013 PyObject *swig_obj[1] ;
14014
14015 if (!args) SWIG_fail;
14016 swig_obj[0] = args;
14017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14020 }
14021 arg1 = reinterpret_cast< wxImage * >(argp1);
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 result = (bool)(arg1)->HasAlpha();
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 {
14029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14038 PyObject *resultobj = 0;
14039 wxImage *arg1 = (wxImage *) 0 ;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 PyObject *swig_obj[1] ;
14043
14044 if (!args) SWIG_fail;
14045 swig_obj[0] = args;
14046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14047 if (!SWIG_IsOK(res1)) {
14048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14049 }
14050 arg1 = reinterpret_cast< wxImage * >(argp1);
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 (arg1)->InitAlpha();
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 resultobj = SWIG_Py_Void();
14058 return resultobj;
14059 fail:
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14065 PyObject *resultobj = 0;
14066 wxImage *arg1 = (wxImage *) 0 ;
14067 int arg2 ;
14068 int arg3 ;
14069 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14070 bool result;
14071 void *argp1 = 0 ;
14072 int res1 = 0 ;
14073 int val2 ;
14074 int ecode2 = 0 ;
14075 int val3 ;
14076 int ecode3 = 0 ;
14077 unsigned char val4 ;
14078 int ecode4 = 0 ;
14079 PyObject * obj0 = 0 ;
14080 PyObject * obj1 = 0 ;
14081 PyObject * obj2 = 0 ;
14082 PyObject * obj3 = 0 ;
14083 char * kwnames[] = {
14084 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14085 };
14086
14087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14089 if (!SWIG_IsOK(res1)) {
14090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14091 }
14092 arg1 = reinterpret_cast< wxImage * >(argp1);
14093 ecode2 = SWIG_AsVal_int(obj1, &val2);
14094 if (!SWIG_IsOK(ecode2)) {
14095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14096 }
14097 arg2 = static_cast< int >(val2);
14098 ecode3 = SWIG_AsVal_int(obj2, &val3);
14099 if (!SWIG_IsOK(ecode3)) {
14100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14101 }
14102 arg3 = static_cast< int >(val3);
14103 if (obj3) {
14104 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14105 if (!SWIG_IsOK(ecode4)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14107 }
14108 arg4 = static_cast< byte >(val4);
14109 }
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14118 }
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj = 0;
14127 wxImage *arg1 = (wxImage *) 0 ;
14128 byte *arg2 = (byte *) 0 ;
14129 byte *arg3 = (byte *) 0 ;
14130 byte *arg4 = (byte *) 0 ;
14131 byte arg5 = (byte) 0 ;
14132 byte arg6 = (byte) 0 ;
14133 byte arg7 = (byte) 0 ;
14134 bool result;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 byte temp2 ;
14138 int res2 = SWIG_TMPOBJ ;
14139 byte temp3 ;
14140 int res3 = SWIG_TMPOBJ ;
14141 byte temp4 ;
14142 int res4 = SWIG_TMPOBJ ;
14143 unsigned char val5 ;
14144 int ecode5 = 0 ;
14145 unsigned char val6 ;
14146 int ecode6 = 0 ;
14147 unsigned char val7 ;
14148 int ecode7 = 0 ;
14149 PyObject * obj0 = 0 ;
14150 PyObject * obj1 = 0 ;
14151 PyObject * obj2 = 0 ;
14152 PyObject * obj3 = 0 ;
14153 char * kwnames[] = {
14154 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14155 };
14156
14157 arg2 = &temp2;
14158 arg3 = &temp3;
14159 arg4 = &temp4;
14160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 if (obj1) {
14167 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14168 if (!SWIG_IsOK(ecode5)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14170 }
14171 arg5 = static_cast< byte >(val5);
14172 }
14173 if (obj2) {
14174 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14175 if (!SWIG_IsOK(ecode6)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14177 }
14178 arg6 = static_cast< byte >(val6);
14179 }
14180 if (obj3) {
14181 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14182 if (!SWIG_IsOK(ecode7)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14184 }
14185 arg7 = static_cast< byte >(val7);
14186 }
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14190 wxPyEndAllowThreads(__tstate);
14191 if (PyErr_Occurred()) SWIG_fail;
14192 }
14193 {
14194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14195 }
14196 if (SWIG_IsTmpObj(res2)) {
14197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14198 } else {
14199 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14201 }
14202 if (SWIG_IsTmpObj(res3)) {
14203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14204 } else {
14205 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14207 }
14208 if (SWIG_IsTmpObj(res4)) {
14209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14210 } else {
14211 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14213 }
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj = 0;
14222 wxImage *arg1 = (wxImage *) 0 ;
14223 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14224 bool result;
14225 void *argp1 = 0 ;
14226 int res1 = 0 ;
14227 unsigned char val2 ;
14228 int ecode2 = 0 ;
14229 PyObject * obj0 = 0 ;
14230 PyObject * obj1 = 0 ;
14231 char * kwnames[] = {
14232 (char *) "self",(char *) "threshold", NULL
14233 };
14234
14235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14237 if (!SWIG_IsOK(res1)) {
14238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14239 }
14240 arg1 = reinterpret_cast< wxImage * >(argp1);
14241 if (obj1) {
14242 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14243 if (!SWIG_IsOK(ecode2)) {
14244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14245 }
14246 arg2 = static_cast< byte >(val2);
14247 }
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 {
14255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14256 }
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj = 0;
14265 wxImage *arg1 = (wxImage *) 0 ;
14266 byte arg2 ;
14267 byte arg3 ;
14268 byte arg4 ;
14269 bool result;
14270 void *argp1 = 0 ;
14271 int res1 = 0 ;
14272 unsigned char val2 ;
14273 int ecode2 = 0 ;
14274 unsigned char val3 ;
14275 int ecode3 = 0 ;
14276 unsigned char val4 ;
14277 int ecode4 = 0 ;
14278 PyObject * obj0 = 0 ;
14279 PyObject * obj1 = 0 ;
14280 PyObject * obj2 = 0 ;
14281 PyObject * obj3 = 0 ;
14282 char * kwnames[] = {
14283 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14284 };
14285
14286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14288 if (!SWIG_IsOK(res1)) {
14289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14290 }
14291 arg1 = reinterpret_cast< wxImage * >(argp1);
14292 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14293 if (!SWIG_IsOK(ecode2)) {
14294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14295 }
14296 arg2 = static_cast< byte >(val2);
14297 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14298 if (!SWIG_IsOK(ecode3)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14300 }
14301 arg3 = static_cast< byte >(val3);
14302 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14303 if (!SWIG_IsOK(ecode4)) {
14304 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14305 }
14306 arg4 = static_cast< byte >(val4);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14315 }
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj = 0;
14324 wxImage *arg1 = (wxImage *) 0 ;
14325 wxImage *arg2 = 0 ;
14326 byte arg3 ;
14327 byte arg4 ;
14328 byte arg5 ;
14329 bool result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 void *argp2 = 0 ;
14333 int res2 = 0 ;
14334 unsigned char val3 ;
14335 int ecode3 = 0 ;
14336 unsigned char val4 ;
14337 int ecode4 = 0 ;
14338 unsigned char val5 ;
14339 int ecode5 = 0 ;
14340 PyObject * obj0 = 0 ;
14341 PyObject * obj1 = 0 ;
14342 PyObject * obj2 = 0 ;
14343 PyObject * obj3 = 0 ;
14344 PyObject * obj4 = 0 ;
14345 char * kwnames[] = {
14346 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14347 };
14348
14349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14351 if (!SWIG_IsOK(res1)) {
14352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14353 }
14354 arg1 = reinterpret_cast< wxImage * >(argp1);
14355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14356 if (!SWIG_IsOK(res2)) {
14357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14358 }
14359 if (!argp2) {
14360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14361 }
14362 arg2 = reinterpret_cast< wxImage * >(argp2);
14363 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14364 if (!SWIG_IsOK(ecode3)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14366 }
14367 arg3 = static_cast< byte >(val3);
14368 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14369 if (!SWIG_IsOK(ecode4)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14371 }
14372 arg4 = static_cast< byte >(val4);
14373 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14374 if (!SWIG_IsOK(ecode5)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14376 }
14377 arg5 = static_cast< byte >(val5);
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14386 }
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj = 0;
14395 wxString *arg1 = 0 ;
14396 bool result;
14397 bool temp1 = false ;
14398 PyObject * obj0 = 0 ;
14399 char * kwnames[] = {
14400 (char *) "filename", NULL
14401 };
14402
14403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14404 {
14405 arg1 = wxString_in_helper(obj0);
14406 if (arg1 == NULL) SWIG_fail;
14407 temp1 = true;
14408 }
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 {
14416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14417 }
14418 {
14419 if (temp1)
14420 delete arg1;
14421 }
14422 return resultobj;
14423 fail:
14424 {
14425 if (temp1)
14426 delete arg1;
14427 }
14428 return NULL;
14429 }
14430
14431
14432 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14433 PyObject *resultobj = 0;
14434 wxString *arg1 = 0 ;
14435 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14436 int result;
14437 bool temp1 = false ;
14438 long val2 ;
14439 int ecode2 = 0 ;
14440 PyObject * obj0 = 0 ;
14441 PyObject * obj1 = 0 ;
14442 char * kwnames[] = {
14443 (char *) "filename",(char *) "type", NULL
14444 };
14445
14446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14447 {
14448 arg1 = wxString_in_helper(obj0);
14449 if (arg1 == NULL) SWIG_fail;
14450 temp1 = true;
14451 }
14452 if (obj1) {
14453 ecode2 = SWIG_AsVal_long(obj1, &val2);
14454 if (!SWIG_IsOK(ecode2)) {
14455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14456 }
14457 arg2 = static_cast< long >(val2);
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 resultobj = SWIG_From_int(static_cast< int >(result));
14466 {
14467 if (temp1)
14468 delete arg1;
14469 }
14470 return resultobj;
14471 fail:
14472 {
14473 if (temp1)
14474 delete arg1;
14475 }
14476 return NULL;
14477 }
14478
14479
14480 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj = 0;
14482 wxImage *arg1 = (wxImage *) 0 ;
14483 wxString *arg2 = 0 ;
14484 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14485 int arg4 = (int) -1 ;
14486 bool result;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 bool temp2 = false ;
14490 long val3 ;
14491 int ecode3 = 0 ;
14492 int val4 ;
14493 int ecode4 = 0 ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 PyObject * obj2 = 0 ;
14497 PyObject * obj3 = 0 ;
14498 char * kwnames[] = {
14499 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14500 };
14501
14502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14504 if (!SWIG_IsOK(res1)) {
14505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14506 }
14507 arg1 = reinterpret_cast< wxImage * >(argp1);
14508 {
14509 arg2 = wxString_in_helper(obj1);
14510 if (arg2 == NULL) SWIG_fail;
14511 temp2 = true;
14512 }
14513 if (obj2) {
14514 ecode3 = SWIG_AsVal_long(obj2, &val3);
14515 if (!SWIG_IsOK(ecode3)) {
14516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14517 }
14518 arg3 = static_cast< long >(val3);
14519 }
14520 if (obj3) {
14521 ecode4 = SWIG_AsVal_int(obj3, &val4);
14522 if (!SWIG_IsOK(ecode4)) {
14523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14524 }
14525 arg4 = static_cast< int >(val4);
14526 }
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14530 wxPyEndAllowThreads(__tstate);
14531 if (PyErr_Occurred()) SWIG_fail;
14532 }
14533 {
14534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14535 }
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 return resultobj;
14541 fail:
14542 {
14543 if (temp2)
14544 delete arg2;
14545 }
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj = 0;
14552 wxImage *arg1 = (wxImage *) 0 ;
14553 wxString *arg2 = 0 ;
14554 wxString *arg3 = 0 ;
14555 int arg4 = (int) -1 ;
14556 bool result;
14557 void *argp1 = 0 ;
14558 int res1 = 0 ;
14559 bool temp2 = false ;
14560 bool temp3 = false ;
14561 int val4 ;
14562 int ecode4 = 0 ;
14563 PyObject * obj0 = 0 ;
14564 PyObject * obj1 = 0 ;
14565 PyObject * obj2 = 0 ;
14566 PyObject * obj3 = 0 ;
14567 char * kwnames[] = {
14568 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14569 };
14570
14571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14573 if (!SWIG_IsOK(res1)) {
14574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14575 }
14576 arg1 = reinterpret_cast< wxImage * >(argp1);
14577 {
14578 arg2 = wxString_in_helper(obj1);
14579 if (arg2 == NULL) SWIG_fail;
14580 temp2 = true;
14581 }
14582 {
14583 arg3 = wxString_in_helper(obj2);
14584 if (arg3 == NULL) SWIG_fail;
14585 temp3 = true;
14586 }
14587 if (obj3) {
14588 ecode4 = SWIG_AsVal_int(obj3, &val4);
14589 if (!SWIG_IsOK(ecode4)) {
14590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14591 }
14592 arg4 = static_cast< int >(val4);
14593 }
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 {
14601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14602 }
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 {
14608 if (temp3)
14609 delete arg3;
14610 }
14611 return resultobj;
14612 fail:
14613 {
14614 if (temp2)
14615 delete arg2;
14616 }
14617 {
14618 if (temp3)
14619 delete arg3;
14620 }
14621 return NULL;
14622 }
14623
14624
14625 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14626 PyObject *resultobj = 0;
14627 wxImage *arg1 = (wxImage *) 0 ;
14628 wxString *arg2 = 0 ;
14629 int arg3 ;
14630 bool result;
14631 void *argp1 = 0 ;
14632 int res1 = 0 ;
14633 bool temp2 = false ;
14634 int val3 ;
14635 int ecode3 = 0 ;
14636 PyObject * obj0 = 0 ;
14637 PyObject * obj1 = 0 ;
14638 PyObject * obj2 = 0 ;
14639 char * kwnames[] = {
14640 (char *) "self",(char *) "name",(char *) "type", NULL
14641 };
14642
14643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14645 if (!SWIG_IsOK(res1)) {
14646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14647 }
14648 arg1 = reinterpret_cast< wxImage * >(argp1);
14649 {
14650 arg2 = wxString_in_helper(obj1);
14651 if (arg2 == NULL) SWIG_fail;
14652 temp2 = true;
14653 }
14654 ecode3 = SWIG_AsVal_int(obj2, &val3);
14655 if (!SWIG_IsOK(ecode3)) {
14656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14657 }
14658 arg3 = static_cast< int >(val3);
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 {
14669 if (temp2)
14670 delete arg2;
14671 }
14672 return resultobj;
14673 fail:
14674 {
14675 if (temp2)
14676 delete arg2;
14677 }
14678 return NULL;
14679 }
14680
14681
14682 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14683 PyObject *resultobj = 0;
14684 wxImage *arg1 = (wxImage *) 0 ;
14685 wxString *arg2 = 0 ;
14686 wxString *arg3 = 0 ;
14687 bool result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 bool temp2 = false ;
14691 bool temp3 = false ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 PyObject * obj2 = 0 ;
14695 char * kwnames[] = {
14696 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14697 };
14698
14699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14701 if (!SWIG_IsOK(res1)) {
14702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14703 }
14704 arg1 = reinterpret_cast< wxImage * >(argp1);
14705 {
14706 arg2 = wxString_in_helper(obj1);
14707 if (arg2 == NULL) SWIG_fail;
14708 temp2 = true;
14709 }
14710 {
14711 arg3 = wxString_in_helper(obj2);
14712 if (arg3 == NULL) SWIG_fail;
14713 temp3 = true;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 {
14722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14723 }
14724 {
14725 if (temp2)
14726 delete arg2;
14727 }
14728 {
14729 if (temp3)
14730 delete arg3;
14731 }
14732 return resultobj;
14733 fail:
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 {
14739 if (temp3)
14740 delete arg3;
14741 }
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj = 0;
14748 wxInputStream *arg1 = 0 ;
14749 bool result;
14750 wxPyInputStream *temp1 ;
14751 bool created1 ;
14752 PyObject * obj0 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "stream", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14758 {
14759 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14760 arg1 = temp1->m_wxis;
14761 created1 = false;
14762 } else {
14763 PyErr_Clear(); // clear the failure of the wxPyConvert above
14764 arg1 = wxPyCBInputStream_create(obj0, false);
14765 if (arg1 == NULL) {
14766 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14767 SWIG_fail;
14768 }
14769 created1 = true;
14770 }
14771 }
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (bool)wxImage::CanRead(*arg1);
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 {
14779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14780 }
14781 {
14782 if (created1) delete arg1;
14783 }
14784 return resultobj;
14785 fail:
14786 {
14787 if (created1) delete arg1;
14788 }
14789 return NULL;
14790 }
14791
14792
14793 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14794 PyObject *resultobj = 0;
14795 wxImage *arg1 = (wxImage *) 0 ;
14796 wxInputStream *arg2 = 0 ;
14797 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14798 int arg4 = (int) -1 ;
14799 bool result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 wxPyInputStream *temp2 ;
14803 bool created2 ;
14804 long val3 ;
14805 int ecode3 = 0 ;
14806 int val4 ;
14807 int ecode4 = 0 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 PyObject * obj2 = 0 ;
14811 PyObject * obj3 = 0 ;
14812 char * kwnames[] = {
14813 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14814 };
14815
14816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14818 if (!SWIG_IsOK(res1)) {
14819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14820 }
14821 arg1 = reinterpret_cast< wxImage * >(argp1);
14822 {
14823 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14824 arg2 = temp2->m_wxis;
14825 created2 = false;
14826 } else {
14827 PyErr_Clear(); // clear the failure of the wxPyConvert above
14828 arg2 = wxPyCBInputStream_create(obj1, false);
14829 if (arg2 == NULL) {
14830 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14831 SWIG_fail;
14832 }
14833 created2 = true;
14834 }
14835 }
14836 if (obj2) {
14837 ecode3 = SWIG_AsVal_long(obj2, &val3);
14838 if (!SWIG_IsOK(ecode3)) {
14839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14840 }
14841 arg3 = static_cast< long >(val3);
14842 }
14843 if (obj3) {
14844 ecode4 = SWIG_AsVal_int(obj3, &val4);
14845 if (!SWIG_IsOK(ecode4)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14847 }
14848 arg4 = static_cast< int >(val4);
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (created2) delete arg2;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (created2) delete arg2;
14866 }
14867 return NULL;
14868 }
14869
14870
14871 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj = 0;
14873 wxImage *arg1 = (wxImage *) 0 ;
14874 wxInputStream *arg2 = 0 ;
14875 wxString *arg3 = 0 ;
14876 int arg4 = (int) -1 ;
14877 bool result;
14878 void *argp1 = 0 ;
14879 int res1 = 0 ;
14880 wxPyInputStream *temp2 ;
14881 bool created2 ;
14882 bool temp3 = false ;
14883 int val4 ;
14884 int ecode4 = 0 ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 PyObject * obj2 = 0 ;
14888 PyObject * obj3 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImage * >(argp1);
14899 {
14900 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14901 arg2 = temp2->m_wxis;
14902 created2 = false;
14903 } else {
14904 PyErr_Clear(); // clear the failure of the wxPyConvert above
14905 arg2 = wxPyCBInputStream_create(obj1, false);
14906 if (arg2 == NULL) {
14907 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14908 SWIG_fail;
14909 }
14910 created2 = true;
14911 }
14912 }
14913 {
14914 arg3 = wxString_in_helper(obj2);
14915 if (arg3 == NULL) SWIG_fail;
14916 temp3 = true;
14917 }
14918 if (obj3) {
14919 ecode4 = SWIG_AsVal_int(obj3, &val4);
14920 if (!SWIG_IsOK(ecode4)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14922 }
14923 arg4 = static_cast< int >(val4);
14924 }
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14928 wxPyEndAllowThreads(__tstate);
14929 if (PyErr_Occurred()) SWIG_fail;
14930 }
14931 {
14932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14933 }
14934 {
14935 if (created2) delete arg2;
14936 }
14937 {
14938 if (temp3)
14939 delete arg3;
14940 }
14941 return resultobj;
14942 fail:
14943 {
14944 if (created2) delete arg2;
14945 }
14946 {
14947 if (temp3)
14948 delete arg3;
14949 }
14950 return NULL;
14951 }
14952
14953
14954 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14955 PyObject *resultobj = 0;
14956 wxImage *arg1 = (wxImage *) 0 ;
14957 bool result;
14958 void *argp1 = 0 ;
14959 int res1 = 0 ;
14960 PyObject *swig_obj[1] ;
14961
14962 if (!args) SWIG_fail;
14963 swig_obj[0] = args;
14964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14965 if (!SWIG_IsOK(res1)) {
14966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14967 }
14968 arg1 = reinterpret_cast< wxImage * >(argp1);
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)(arg1)->Ok();
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14985 PyObject *resultobj = 0;
14986 wxImage *arg1 = (wxImage *) 0 ;
14987 int result;
14988 void *argp1 = 0 ;
14989 int res1 = 0 ;
14990 PyObject *swig_obj[1] ;
14991
14992 if (!args) SWIG_fail;
14993 swig_obj[0] = args;
14994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14995 if (!SWIG_IsOK(res1)) {
14996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14997 }
14998 arg1 = reinterpret_cast< wxImage * >(argp1);
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (int)(arg1)->GetWidth();
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 resultobj = SWIG_From_int(static_cast< int >(result));
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15013 PyObject *resultobj = 0;
15014 wxImage *arg1 = (wxImage *) 0 ;
15015 int result;
15016 void *argp1 = 0 ;
15017 int res1 = 0 ;
15018 PyObject *swig_obj[1] ;
15019
15020 if (!args) SWIG_fail;
15021 swig_obj[0] = args;
15022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15025 }
15026 arg1 = reinterpret_cast< wxImage * >(argp1);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (int)(arg1)->GetHeight();
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxImage *arg1 = (wxImage *) 0 ;
15043 wxSize result;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 PyObject *swig_obj[1] ;
15047
15048 if (!args) SWIG_fail;
15049 swig_obj[0] = args;
15050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15051 if (!SWIG_IsOK(res1)) {
15052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15053 }
15054 arg1 = reinterpret_cast< wxImage * >(argp1);
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = wxImage_GetSize(arg1);
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj = 0;
15070 wxImage *arg1 = (wxImage *) 0 ;
15071 wxRect *arg2 = 0 ;
15072 SwigValueWrapper<wxImage > result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 wxRect temp2 ;
15076 PyObject * obj0 = 0 ;
15077 PyObject * obj1 = 0 ;
15078 char * kwnames[] = {
15079 (char *) "self",(char *) "rect", NULL
15080 };
15081
15082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15084 if (!SWIG_IsOK(res1)) {
15085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15086 }
15087 arg1 = reinterpret_cast< wxImage * >(argp1);
15088 {
15089 arg2 = &temp2;
15090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15091 }
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj = 0;
15107 wxImage *arg1 = (wxImage *) 0 ;
15108 wxSize *arg2 = 0 ;
15109 wxPoint *arg3 = 0 ;
15110 int arg4 = (int) -1 ;
15111 int arg5 = (int) -1 ;
15112 int arg6 = (int) -1 ;
15113 SwigValueWrapper<wxImage > result;
15114 void *argp1 = 0 ;
15115 int res1 = 0 ;
15116 wxSize temp2 ;
15117 wxPoint temp3 ;
15118 int val4 ;
15119 int ecode4 = 0 ;
15120 int val5 ;
15121 int ecode5 = 0 ;
15122 int val6 ;
15123 int ecode6 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 PyObject * obj3 = 0 ;
15128 PyObject * obj4 = 0 ;
15129 PyObject * obj5 = 0 ;
15130 char * kwnames[] = {
15131 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15132 };
15133
15134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15136 if (!SWIG_IsOK(res1)) {
15137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15138 }
15139 arg1 = reinterpret_cast< wxImage * >(argp1);
15140 {
15141 arg2 = &temp2;
15142 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15143 }
15144 {
15145 arg3 = &temp3;
15146 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15147 }
15148 if (obj3) {
15149 ecode4 = SWIG_AsVal_int(obj3, &val4);
15150 if (!SWIG_IsOK(ecode4)) {
15151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15152 }
15153 arg4 = static_cast< int >(val4);
15154 }
15155 if (obj4) {
15156 ecode5 = SWIG_AsVal_int(obj4, &val5);
15157 if (!SWIG_IsOK(ecode5)) {
15158 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15159 }
15160 arg5 = static_cast< int >(val5);
15161 }
15162 if (obj5) {
15163 ecode6 = SWIG_AsVal_int(obj5, &val6);
15164 if (!SWIG_IsOK(ecode6)) {
15165 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15166 }
15167 arg6 = static_cast< int >(val6);
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15183 PyObject *resultobj = 0;
15184 wxImage *arg1 = (wxImage *) 0 ;
15185 SwigValueWrapper<wxImage > result;
15186 void *argp1 = 0 ;
15187 int res1 = 0 ;
15188 PyObject *swig_obj[1] ;
15189
15190 if (!args) SWIG_fail;
15191 swig_obj[0] = args;
15192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15193 if (!SWIG_IsOK(res1)) {
15194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15195 }
15196 arg1 = reinterpret_cast< wxImage * >(argp1);
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 result = (arg1)->Copy();
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj = 0;
15212 wxImage *arg1 = (wxImage *) 0 ;
15213 wxImage *arg2 = 0 ;
15214 int arg3 ;
15215 int arg4 ;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 void *argp2 = 0 ;
15219 int res2 = 0 ;
15220 int val3 ;
15221 int ecode3 = 0 ;
15222 int val4 ;
15223 int ecode4 = 0 ;
15224 PyObject * obj0 = 0 ;
15225 PyObject * obj1 = 0 ;
15226 PyObject * obj2 = 0 ;
15227 PyObject * obj3 = 0 ;
15228 char * kwnames[] = {
15229 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15230 };
15231
15232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15236 }
15237 arg1 = reinterpret_cast< wxImage * >(argp1);
15238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15239 if (!SWIG_IsOK(res2)) {
15240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15241 }
15242 if (!argp2) {
15243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15244 }
15245 arg2 = reinterpret_cast< wxImage * >(argp2);
15246 ecode3 = SWIG_AsVal_int(obj2, &val3);
15247 if (!SWIG_IsOK(ecode3)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15249 }
15250 arg3 = static_cast< int >(val3);
15251 ecode4 = SWIG_AsVal_int(obj3, &val4);
15252 if (!SWIG_IsOK(ecode4)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15254 }
15255 arg4 = static_cast< int >(val4);
15256 {
15257 PyThreadState* __tstate = wxPyBeginAllowThreads();
15258 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15259 wxPyEndAllowThreads(__tstate);
15260 if (PyErr_Occurred()) SWIG_fail;
15261 }
15262 resultobj = SWIG_Py_Void();
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15270 PyObject *resultobj = 0;
15271 wxImage *arg1 = (wxImage *) 0 ;
15272 PyObject *result = 0 ;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 PyObject *swig_obj[1] ;
15276
15277 if (!args) SWIG_fail;
15278 swig_obj[0] = args;
15279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15282 }
15283 arg1 = reinterpret_cast< wxImage * >(argp1);
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = (PyObject *)wxImage_GetData(arg1);
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = result;
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15298 PyObject *resultobj = 0;
15299 wxImage *arg1 = (wxImage *) 0 ;
15300 buffer arg2 ;
15301 int arg3 ;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "data", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage * >(argp1);
15316 {
15317 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15318 }
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 wxImage_SetData(arg1,arg2,arg3);
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 resultobj = SWIG_Py_Void();
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15333 PyObject *resultobj = 0;
15334 wxImage *arg1 = (wxImage *) 0 ;
15335 PyObject *result = 0 ;
15336 void *argp1 = 0 ;
15337 int res1 = 0 ;
15338 PyObject *swig_obj[1] ;
15339
15340 if (!args) SWIG_fail;
15341 swig_obj[0] = args;
15342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15343 if (!SWIG_IsOK(res1)) {
15344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15345 }
15346 arg1 = reinterpret_cast< wxImage * >(argp1);
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 resultobj = result;
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15361 PyObject *resultobj = 0;
15362 wxImage *arg1 = (wxImage *) 0 ;
15363 buffer arg2 ;
15364 int arg3 ;
15365 void *argp1 = 0 ;
15366 int res1 = 0 ;
15367 PyObject * obj0 = 0 ;
15368 PyObject * obj1 = 0 ;
15369 char * kwnames[] = {
15370 (char *) "self",(char *) "data", NULL
15371 };
15372
15373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15377 }
15378 arg1 = reinterpret_cast< wxImage * >(argp1);
15379 {
15380 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15381 }
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 wxImage_SetDataBuffer(arg1,arg2,arg3);
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 resultobj = SWIG_Py_Void();
15389 return resultobj;
15390 fail:
15391 return NULL;
15392 }
15393
15394
15395 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15396 PyObject *resultobj = 0;
15397 wxImage *arg1 = (wxImage *) 0 ;
15398 PyObject *result = 0 ;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject *swig_obj[1] ;
15402
15403 if (!args) SWIG_fail;
15404 swig_obj[0] = args;
15405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15406 if (!SWIG_IsOK(res1)) {
15407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15408 }
15409 arg1 = reinterpret_cast< wxImage * >(argp1);
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = (PyObject *)wxImage_GetAlphaData(arg1);
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 resultobj = result;
15417 return resultobj;
15418 fail:
15419 return NULL;
15420 }
15421
15422
15423 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15424 PyObject *resultobj = 0;
15425 wxImage *arg1 = (wxImage *) 0 ;
15426 buffer arg2 ;
15427 int arg3 ;
15428 void *argp1 = 0 ;
15429 int res1 = 0 ;
15430 PyObject * obj0 = 0 ;
15431 PyObject * obj1 = 0 ;
15432 char * kwnames[] = {
15433 (char *) "self",(char *) "alpha", NULL
15434 };
15435
15436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15438 if (!SWIG_IsOK(res1)) {
15439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15440 }
15441 arg1 = reinterpret_cast< wxImage * >(argp1);
15442 {
15443 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15444 }
15445 {
15446 PyThreadState* __tstate = wxPyBeginAllowThreads();
15447 wxImage_SetAlphaData(arg1,arg2,arg3);
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 resultobj = SWIG_Py_Void();
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15459 PyObject *resultobj = 0;
15460 wxImage *arg1 = (wxImage *) 0 ;
15461 PyObject *result = 0 ;
15462 void *argp1 = 0 ;
15463 int res1 = 0 ;
15464 PyObject *swig_obj[1] ;
15465
15466 if (!args) SWIG_fail;
15467 swig_obj[0] = args;
15468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15469 if (!SWIG_IsOK(res1)) {
15470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15471 }
15472 arg1 = reinterpret_cast< wxImage * >(argp1);
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = result;
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxImage *arg1 = (wxImage *) 0 ;
15489 buffer arg2 ;
15490 int arg3 ;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 char * kwnames[] = {
15496 (char *) "self",(char *) "alpha", NULL
15497 };
15498
15499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15501 if (!SWIG_IsOK(res1)) {
15502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15503 }
15504 arg1 = reinterpret_cast< wxImage * >(argp1);
15505 {
15506 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15507 }
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_Py_Void();
15515 return resultobj;
15516 fail:
15517 return NULL;
15518 }
15519
15520
15521 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15522 PyObject *resultobj = 0;
15523 wxImage *arg1 = (wxImage *) 0 ;
15524 byte arg2 ;
15525 byte arg3 ;
15526 byte arg4 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 unsigned char val2 ;
15530 int ecode2 = 0 ;
15531 unsigned char val3 ;
15532 int ecode3 = 0 ;
15533 unsigned char val4 ;
15534 int ecode4 = 0 ;
15535 PyObject * obj0 = 0 ;
15536 PyObject * obj1 = 0 ;
15537 PyObject * obj2 = 0 ;
15538 PyObject * obj3 = 0 ;
15539 char * kwnames[] = {
15540 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15541 };
15542
15543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15545 if (!SWIG_IsOK(res1)) {
15546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15547 }
15548 arg1 = reinterpret_cast< wxImage * >(argp1);
15549 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15550 if (!SWIG_IsOK(ecode2)) {
15551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15552 }
15553 arg2 = static_cast< byte >(val2);
15554 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15555 if (!SWIG_IsOK(ecode3)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15557 }
15558 arg3 = static_cast< byte >(val3);
15559 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15560 if (!SWIG_IsOK(ecode4)) {
15561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15562 }
15563 arg4 = static_cast< byte >(val4);
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 (arg1)->SetMaskColour(arg2,arg3,arg4);
15567 wxPyEndAllowThreads(__tstate);
15568 if (PyErr_Occurred()) SWIG_fail;
15569 }
15570 resultobj = SWIG_Py_Void();
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15578 PyObject *resultobj = 0;
15579 wxImage *arg1 = (wxImage *) 0 ;
15580 byte *arg2 = (byte *) 0 ;
15581 byte *arg3 = (byte *) 0 ;
15582 byte *arg4 = (byte *) 0 ;
15583 void *argp1 = 0 ;
15584 int res1 = 0 ;
15585 byte temp2 ;
15586 int res2 = SWIG_TMPOBJ ;
15587 byte temp3 ;
15588 int res3 = SWIG_TMPOBJ ;
15589 byte temp4 ;
15590 int res4 = SWIG_TMPOBJ ;
15591 PyObject *swig_obj[1] ;
15592
15593 arg2 = &temp2;
15594 arg3 = &temp3;
15595 arg4 = &temp4;
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = SWIG_Py_Void();
15610 if (SWIG_IsTmpObj(res2)) {
15611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15612 } else {
15613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15615 }
15616 if (SWIG_IsTmpObj(res3)) {
15617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15618 } else {
15619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15621 }
15622 if (SWIG_IsTmpObj(res4)) {
15623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15624 } else {
15625 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15635 PyObject *resultobj = 0;
15636 wxImage *arg1 = (wxImage *) 0 ;
15637 byte result;
15638 void *argp1 = 0 ;
15639 int res1 = 0 ;
15640 PyObject *swig_obj[1] ;
15641
15642 if (!args) SWIG_fail;
15643 swig_obj[0] = args;
15644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15645 if (!SWIG_IsOK(res1)) {
15646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15647 }
15648 arg1 = reinterpret_cast< wxImage * >(argp1);
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (byte)(arg1)->GetMaskRed();
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15663 PyObject *resultobj = 0;
15664 wxImage *arg1 = (wxImage *) 0 ;
15665 byte result;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 PyObject *swig_obj[1] ;
15669
15670 if (!args) SWIG_fail;
15671 swig_obj[0] = args;
15672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15673 if (!SWIG_IsOK(res1)) {
15674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15675 }
15676 arg1 = reinterpret_cast< wxImage * >(argp1);
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (byte)(arg1)->GetMaskGreen();
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15691 PyObject *resultobj = 0;
15692 wxImage *arg1 = (wxImage *) 0 ;
15693 byte result;
15694 void *argp1 = 0 ;
15695 int res1 = 0 ;
15696 PyObject *swig_obj[1] ;
15697
15698 if (!args) SWIG_fail;
15699 swig_obj[0] = args;
15700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15701 if (!SWIG_IsOK(res1)) {
15702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15703 }
15704 arg1 = reinterpret_cast< wxImage * >(argp1);
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 result = (byte)(arg1)->GetMaskBlue();
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj = 0;
15720 wxImage *arg1 = (wxImage *) 0 ;
15721 bool arg2 = (bool) true ;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 bool val2 ;
15725 int ecode2 = 0 ;
15726 PyObject * obj0 = 0 ;
15727 PyObject * obj1 = 0 ;
15728 char * kwnames[] = {
15729 (char *) "self",(char *) "mask", NULL
15730 };
15731
15732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15736 }
15737 arg1 = reinterpret_cast< wxImage * >(argp1);
15738 if (obj1) {
15739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15740 if (!SWIG_IsOK(ecode2)) {
15741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15742 }
15743 arg2 = static_cast< bool >(val2);
15744 }
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 (arg1)->SetMask(arg2);
15748 wxPyEndAllowThreads(__tstate);
15749 if (PyErr_Occurred()) SWIG_fail;
15750 }
15751 resultobj = SWIG_Py_Void();
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15759 PyObject *resultobj = 0;
15760 wxImage *arg1 = (wxImage *) 0 ;
15761 bool result;
15762 void *argp1 = 0 ;
15763 int res1 = 0 ;
15764 PyObject *swig_obj[1] ;
15765
15766 if (!args) SWIG_fail;
15767 swig_obj[0] = args;
15768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15769 if (!SWIG_IsOK(res1)) {
15770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15771 }
15772 arg1 = reinterpret_cast< wxImage * >(argp1);
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 result = (bool)(arg1)->HasMask();
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 {
15780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15781 }
15782 return resultobj;
15783 fail:
15784 return NULL;
15785 }
15786
15787
15788 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15789 PyObject *resultobj = 0;
15790 wxImage *arg1 = (wxImage *) 0 ;
15791 double arg2 ;
15792 wxPoint *arg3 = 0 ;
15793 bool arg4 = (bool) true ;
15794 wxPoint *arg5 = (wxPoint *) NULL ;
15795 SwigValueWrapper<wxImage > result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 double val2 ;
15799 int ecode2 = 0 ;
15800 wxPoint temp3 ;
15801 bool val4 ;
15802 int ecode4 = 0 ;
15803 void *argp5 = 0 ;
15804 int res5 = 0 ;
15805 PyObject * obj0 = 0 ;
15806 PyObject * obj1 = 0 ;
15807 PyObject * obj2 = 0 ;
15808 PyObject * obj3 = 0 ;
15809 PyObject * obj4 = 0 ;
15810 char * kwnames[] = {
15811 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15812 };
15813
15814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15816 if (!SWIG_IsOK(res1)) {
15817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15818 }
15819 arg1 = reinterpret_cast< wxImage * >(argp1);
15820 ecode2 = SWIG_AsVal_double(obj1, &val2);
15821 if (!SWIG_IsOK(ecode2)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15823 }
15824 arg2 = static_cast< double >(val2);
15825 {
15826 arg3 = &temp3;
15827 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15828 }
15829 if (obj3) {
15830 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15831 if (!SWIG_IsOK(ecode4)) {
15832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15833 }
15834 arg4 = static_cast< bool >(val4);
15835 }
15836 if (obj4) {
15837 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15838 if (!SWIG_IsOK(res5)) {
15839 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15840 }
15841 arg5 = reinterpret_cast< wxPoint * >(argp5);
15842 }
15843 {
15844 PyThreadState* __tstate = wxPyBeginAllowThreads();
15845 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15846 wxPyEndAllowThreads(__tstate);
15847 if (PyErr_Occurred()) SWIG_fail;
15848 }
15849 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15850 return resultobj;
15851 fail:
15852 return NULL;
15853 }
15854
15855
15856 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15857 PyObject *resultobj = 0;
15858 wxImage *arg1 = (wxImage *) 0 ;
15859 bool arg2 = (bool) true ;
15860 SwigValueWrapper<wxImage > result;
15861 void *argp1 = 0 ;
15862 int res1 = 0 ;
15863 bool val2 ;
15864 int ecode2 = 0 ;
15865 PyObject * obj0 = 0 ;
15866 PyObject * obj1 = 0 ;
15867 char * kwnames[] = {
15868 (char *) "self",(char *) "clockwise", NULL
15869 };
15870
15871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15873 if (!SWIG_IsOK(res1)) {
15874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15875 }
15876 arg1 = reinterpret_cast< wxImage * >(argp1);
15877 if (obj1) {
15878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15879 if (!SWIG_IsOK(ecode2)) {
15880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15881 }
15882 arg2 = static_cast< bool >(val2);
15883 }
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 result = (arg1)->Rotate90(arg2);
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15898 PyObject *resultobj = 0;
15899 wxImage *arg1 = (wxImage *) 0 ;
15900 bool arg2 = (bool) true ;
15901 SwigValueWrapper<wxImage > result;
15902 void *argp1 = 0 ;
15903 int res1 = 0 ;
15904 bool val2 ;
15905 int ecode2 = 0 ;
15906 PyObject * obj0 = 0 ;
15907 PyObject * obj1 = 0 ;
15908 char * kwnames[] = {
15909 (char *) "self",(char *) "horizontally", NULL
15910 };
15911
15912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15914 if (!SWIG_IsOK(res1)) {
15915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15916 }
15917 arg1 = reinterpret_cast< wxImage * >(argp1);
15918 if (obj1) {
15919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15920 if (!SWIG_IsOK(ecode2)) {
15921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15922 }
15923 arg2 = static_cast< bool >(val2);
15924 }
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 result = (arg1)->Mirror(arg2);
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj = 0;
15940 wxImage *arg1 = (wxImage *) 0 ;
15941 byte arg2 ;
15942 byte arg3 ;
15943 byte arg4 ;
15944 byte arg5 ;
15945 byte arg6 ;
15946 byte arg7 ;
15947 void *argp1 = 0 ;
15948 int res1 = 0 ;
15949 unsigned char val2 ;
15950 int ecode2 = 0 ;
15951 unsigned char val3 ;
15952 int ecode3 = 0 ;
15953 unsigned char val4 ;
15954 int ecode4 = 0 ;
15955 unsigned char val5 ;
15956 int ecode5 = 0 ;
15957 unsigned char val6 ;
15958 int ecode6 = 0 ;
15959 unsigned char val7 ;
15960 int ecode7 = 0 ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 PyObject * obj3 = 0 ;
15965 PyObject * obj4 = 0 ;
15966 PyObject * obj5 = 0 ;
15967 PyObject * obj6 = 0 ;
15968 char * kwnames[] = {
15969 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15970 };
15971
15972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15974 if (!SWIG_IsOK(res1)) {
15975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15976 }
15977 arg1 = reinterpret_cast< wxImage * >(argp1);
15978 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15979 if (!SWIG_IsOK(ecode2)) {
15980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15981 }
15982 arg2 = static_cast< byte >(val2);
15983 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15984 if (!SWIG_IsOK(ecode3)) {
15985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15986 }
15987 arg3 = static_cast< byte >(val3);
15988 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15989 if (!SWIG_IsOK(ecode4)) {
15990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15991 }
15992 arg4 = static_cast< byte >(val4);
15993 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15994 if (!SWIG_IsOK(ecode5)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15996 }
15997 arg5 = static_cast< byte >(val5);
15998 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15999 if (!SWIG_IsOK(ecode6)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16001 }
16002 arg6 = static_cast< byte >(val6);
16003 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16004 if (!SWIG_IsOK(ecode7)) {
16005 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16006 }
16007 arg7 = static_cast< byte >(val7);
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 resultobj = SWIG_Py_Void();
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16022 PyObject *resultobj = 0;
16023 wxImage *arg1 = (wxImage *) 0 ;
16024 double arg2 = (double) 0.299 ;
16025 double arg3 = (double) 0.587 ;
16026 double arg4 = (double) 0.114 ;
16027 SwigValueWrapper<wxImage > result;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 double val2 ;
16031 int ecode2 = 0 ;
16032 double val3 ;
16033 int ecode3 = 0 ;
16034 double val4 ;
16035 int ecode4 = 0 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 PyObject * obj2 = 0 ;
16039 PyObject * obj3 = 0 ;
16040 char * kwnames[] = {
16041 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16042 };
16043
16044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16046 if (!SWIG_IsOK(res1)) {
16047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16048 }
16049 arg1 = reinterpret_cast< wxImage * >(argp1);
16050 if (obj1) {
16051 ecode2 = SWIG_AsVal_double(obj1, &val2);
16052 if (!SWIG_IsOK(ecode2)) {
16053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16054 }
16055 arg2 = static_cast< double >(val2);
16056 }
16057 if (obj2) {
16058 ecode3 = SWIG_AsVal_double(obj2, &val3);
16059 if (!SWIG_IsOK(ecode3)) {
16060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16061 }
16062 arg3 = static_cast< double >(val3);
16063 }
16064 if (obj3) {
16065 ecode4 = SWIG_AsVal_double(obj3, &val4);
16066 if (!SWIG_IsOK(ecode4)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16068 }
16069 arg4 = static_cast< double >(val4);
16070 }
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj = 0;
16086 wxImage *arg1 = (wxImage *) 0 ;
16087 byte arg2 ;
16088 byte arg3 ;
16089 byte arg4 ;
16090 SwigValueWrapper<wxImage > result;
16091 void *argp1 = 0 ;
16092 int res1 = 0 ;
16093 unsigned char val2 ;
16094 int ecode2 = 0 ;
16095 unsigned char val3 ;
16096 int ecode3 = 0 ;
16097 unsigned char val4 ;
16098 int ecode4 = 0 ;
16099 PyObject * obj0 = 0 ;
16100 PyObject * obj1 = 0 ;
16101 PyObject * obj2 = 0 ;
16102 PyObject * obj3 = 0 ;
16103 char * kwnames[] = {
16104 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16105 };
16106
16107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16109 if (!SWIG_IsOK(res1)) {
16110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16111 }
16112 arg1 = reinterpret_cast< wxImage * >(argp1);
16113 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16114 if (!SWIG_IsOK(ecode2)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16116 }
16117 arg2 = static_cast< byte >(val2);
16118 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16119 if (!SWIG_IsOK(ecode3)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16121 }
16122 arg3 = static_cast< byte >(val3);
16123 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16124 if (!SWIG_IsOK(ecode4)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16126 }
16127 arg4 = static_cast< byte >(val4);
16128 {
16129 PyThreadState* __tstate = wxPyBeginAllowThreads();
16130 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj = 0;
16143 wxImage *arg1 = (wxImage *) 0 ;
16144 wxString *arg2 = 0 ;
16145 wxString *arg3 = 0 ;
16146 void *argp1 = 0 ;
16147 int res1 = 0 ;
16148 bool temp2 = false ;
16149 bool temp3 = false ;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 PyObject * obj2 = 0 ;
16153 char * kwnames[] = {
16154 (char *) "self",(char *) "name",(char *) "value", NULL
16155 };
16156
16157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16159 if (!SWIG_IsOK(res1)) {
16160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16161 }
16162 arg1 = reinterpret_cast< wxImage * >(argp1);
16163 {
16164 arg2 = wxString_in_helper(obj1);
16165 if (arg2 == NULL) SWIG_fail;
16166 temp2 = true;
16167 }
16168 {
16169 arg3 = wxString_in_helper(obj2);
16170 if (arg3 == NULL) SWIG_fail;
16171 temp3 = true;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16176 wxPyEndAllowThreads(__tstate);
16177 if (PyErr_Occurred()) SWIG_fail;
16178 }
16179 resultobj = SWIG_Py_Void();
16180 {
16181 if (temp2)
16182 delete arg2;
16183 }
16184 {
16185 if (temp3)
16186 delete arg3;
16187 }
16188 return resultobj;
16189 fail:
16190 {
16191 if (temp2)
16192 delete arg2;
16193 }
16194 {
16195 if (temp3)
16196 delete arg3;
16197 }
16198 return NULL;
16199 }
16200
16201
16202 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16203 PyObject *resultobj = 0;
16204 wxImage *arg1 = (wxImage *) 0 ;
16205 wxString *arg2 = 0 ;
16206 int arg3 ;
16207 void *argp1 = 0 ;
16208 int res1 = 0 ;
16209 bool temp2 = false ;
16210 int val3 ;
16211 int ecode3 = 0 ;
16212 PyObject * obj0 = 0 ;
16213 PyObject * obj1 = 0 ;
16214 PyObject * obj2 = 0 ;
16215 char * kwnames[] = {
16216 (char *) "self",(char *) "name",(char *) "value", NULL
16217 };
16218
16219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16223 }
16224 arg1 = reinterpret_cast< wxImage * >(argp1);
16225 {
16226 arg2 = wxString_in_helper(obj1);
16227 if (arg2 == NULL) SWIG_fail;
16228 temp2 = true;
16229 }
16230 ecode3 = SWIG_AsVal_int(obj2, &val3);
16231 if (!SWIG_IsOK(ecode3)) {
16232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16233 }
16234 arg3 = static_cast< int >(val3);
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 (arg1)->SetOption((wxString const &)*arg2,arg3);
16238 wxPyEndAllowThreads(__tstate);
16239 if (PyErr_Occurred()) SWIG_fail;
16240 }
16241 resultobj = SWIG_Py_Void();
16242 {
16243 if (temp2)
16244 delete arg2;
16245 }
16246 return resultobj;
16247 fail:
16248 {
16249 if (temp2)
16250 delete arg2;
16251 }
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxImage *arg1 = (wxImage *) 0 ;
16259 wxString *arg2 = 0 ;
16260 wxString result;
16261 void *argp1 = 0 ;
16262 int res1 = 0 ;
16263 bool temp2 = false ;
16264 PyObject * obj0 = 0 ;
16265 PyObject * obj1 = 0 ;
16266 char * kwnames[] = {
16267 (char *) "self",(char *) "name", NULL
16268 };
16269
16270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16272 if (!SWIG_IsOK(res1)) {
16273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16274 }
16275 arg1 = reinterpret_cast< wxImage * >(argp1);
16276 {
16277 arg2 = wxString_in_helper(obj1);
16278 if (arg2 == NULL) SWIG_fail;
16279 temp2 = true;
16280 }
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16284 wxPyEndAllowThreads(__tstate);
16285 if (PyErr_Occurred()) SWIG_fail;
16286 }
16287 {
16288 #if wxUSE_UNICODE
16289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16290 #else
16291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16292 #endif
16293 }
16294 {
16295 if (temp2)
16296 delete arg2;
16297 }
16298 return resultobj;
16299 fail:
16300 {
16301 if (temp2)
16302 delete arg2;
16303 }
16304 return NULL;
16305 }
16306
16307
16308 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16309 PyObject *resultobj = 0;
16310 wxImage *arg1 = (wxImage *) 0 ;
16311 wxString *arg2 = 0 ;
16312 int result;
16313 void *argp1 = 0 ;
16314 int res1 = 0 ;
16315 bool temp2 = false ;
16316 PyObject * obj0 = 0 ;
16317 PyObject * obj1 = 0 ;
16318 char * kwnames[] = {
16319 (char *) "self",(char *) "name", NULL
16320 };
16321
16322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16324 if (!SWIG_IsOK(res1)) {
16325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16326 }
16327 arg1 = reinterpret_cast< wxImage * >(argp1);
16328 {
16329 arg2 = wxString_in_helper(obj1);
16330 if (arg2 == NULL) SWIG_fail;
16331 temp2 = true;
16332 }
16333 {
16334 PyThreadState* __tstate = wxPyBeginAllowThreads();
16335 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16336 wxPyEndAllowThreads(__tstate);
16337 if (PyErr_Occurred()) SWIG_fail;
16338 }
16339 resultobj = SWIG_From_int(static_cast< int >(result));
16340 {
16341 if (temp2)
16342 delete arg2;
16343 }
16344 return resultobj;
16345 fail:
16346 {
16347 if (temp2)
16348 delete arg2;
16349 }
16350 return NULL;
16351 }
16352
16353
16354 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16355 PyObject *resultobj = 0;
16356 wxImage *arg1 = (wxImage *) 0 ;
16357 wxString *arg2 = 0 ;
16358 bool result;
16359 void *argp1 = 0 ;
16360 int res1 = 0 ;
16361 bool temp2 = false ;
16362 PyObject * obj0 = 0 ;
16363 PyObject * obj1 = 0 ;
16364 char * kwnames[] = {
16365 (char *) "self",(char *) "name", NULL
16366 };
16367
16368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16370 if (!SWIG_IsOK(res1)) {
16371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16372 }
16373 arg1 = reinterpret_cast< wxImage * >(argp1);
16374 {
16375 arg2 = wxString_in_helper(obj1);
16376 if (arg2 == NULL) SWIG_fail;
16377 temp2 = true;
16378 }
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 {
16386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16387 }
16388 {
16389 if (temp2)
16390 delete arg2;
16391 }
16392 return resultobj;
16393 fail:
16394 {
16395 if (temp2)
16396 delete arg2;
16397 }
16398 return NULL;
16399 }
16400
16401
16402 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16403 PyObject *resultobj = 0;
16404 wxImage *arg1 = (wxImage *) 0 ;
16405 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16406 unsigned long result;
16407 void *argp1 = 0 ;
16408 int res1 = 0 ;
16409 unsigned long val2 ;
16410 int ecode2 = 0 ;
16411 PyObject * obj0 = 0 ;
16412 PyObject * obj1 = 0 ;
16413 char * kwnames[] = {
16414 (char *) "self",(char *) "stopafter", NULL
16415 };
16416
16417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16419 if (!SWIG_IsOK(res1)) {
16420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16421 }
16422 arg1 = reinterpret_cast< wxImage * >(argp1);
16423 if (obj1) {
16424 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16425 if (!SWIG_IsOK(ecode2)) {
16426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16427 }
16428 arg2 = static_cast< unsigned long >(val2);
16429 }
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (unsigned long)(arg1)->CountColours(arg2);
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 wxImageHistogram *arg2 = 0 ;
16447 unsigned long result;
16448 void *argp1 = 0 ;
16449 int res1 = 0 ;
16450 void *argp2 = 0 ;
16451 int res2 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 char * kwnames[] = {
16455 (char *) "self",(char *) "h", NULL
16456 };
16457
16458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16460 if (!SWIG_IsOK(res1)) {
16461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16462 }
16463 arg1 = reinterpret_cast< wxImage * >(argp1);
16464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16465 if (!SWIG_IsOK(res2)) {
16466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16467 }
16468 if (!argp2) {
16469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16470 }
16471 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16472 {
16473 PyThreadState* __tstate = wxPyBeginAllowThreads();
16474 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16475 wxPyEndAllowThreads(__tstate);
16476 if (PyErr_Occurred()) SWIG_fail;
16477 }
16478 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = 0;
16487 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 PyObject * obj0 = 0 ;
16491 char * kwnames[] = {
16492 (char *) "handler", NULL
16493 };
16494
16495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16497 if (!SWIG_IsOK(res1)) {
16498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16499 }
16500 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 wxImage::AddHandler(arg1);
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_Py_Void();
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj = 0;
16516 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16517 void *argp1 = 0 ;
16518 int res1 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 char * kwnames[] = {
16521 (char *) "handler", NULL
16522 };
16523
16524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16526 if (!SWIG_IsOK(res1)) {
16527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16528 }
16529 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 wxImage::InsertHandler(arg1);
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 resultobj = SWIG_Py_Void();
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj = 0;
16545 wxString *arg1 = 0 ;
16546 bool result;
16547 bool temp1 = false ;
16548 PyObject * obj0 = 0 ;
16549 char * kwnames[] = {
16550 (char *) "name", NULL
16551 };
16552
16553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16554 {
16555 arg1 = wxString_in_helper(obj0);
16556 if (arg1 == NULL) SWIG_fail;
16557 temp1 = true;
16558 }
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 {
16566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16567 }
16568 {
16569 if (temp1)
16570 delete arg1;
16571 }
16572 return resultobj;
16573 fail:
16574 {
16575 if (temp1)
16576 delete arg1;
16577 }
16578 return NULL;
16579 }
16580
16581
16582 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16583 PyObject *resultobj = 0;
16584 PyObject *result = 0 ;
16585
16586 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (PyObject *)wxImage_GetHandlers();
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = result;
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16601 PyObject *resultobj = 0;
16602 wxString result;
16603
16604 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = wxImage::GetImageExtWildcard();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 {
16612 #if wxUSE_UNICODE
16613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16614 #else
16615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16616 #endif
16617 }
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16625 PyObject *resultobj = 0;
16626 wxImage *arg1 = (wxImage *) 0 ;
16627 int arg2 = (int) -1 ;
16628 wxBitmap result;
16629 void *argp1 = 0 ;
16630 int res1 = 0 ;
16631 int val2 ;
16632 int ecode2 = 0 ;
16633 PyObject * obj0 = 0 ;
16634 PyObject * obj1 = 0 ;
16635 char * kwnames[] = {
16636 (char *) "self",(char *) "depth", NULL
16637 };
16638
16639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16641 if (!SWIG_IsOK(res1)) {
16642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16643 }
16644 arg1 = reinterpret_cast< wxImage * >(argp1);
16645 if (obj1) {
16646 ecode2 = SWIG_AsVal_int(obj1, &val2);
16647 if (!SWIG_IsOK(ecode2)) {
16648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16649 }
16650 arg2 = static_cast< int >(val2);
16651 }
16652 {
16653 if (!wxPyCheckForApp()) SWIG_fail;
16654 PyThreadState* __tstate = wxPyBeginAllowThreads();
16655 result = wxImage_ConvertToBitmap(arg1,arg2);
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj = 0;
16668 wxImage *arg1 = (wxImage *) 0 ;
16669 byte arg2 ;
16670 byte arg3 ;
16671 byte arg4 ;
16672 wxBitmap result;
16673 void *argp1 = 0 ;
16674 int res1 = 0 ;
16675 unsigned char val2 ;
16676 int ecode2 = 0 ;
16677 unsigned char val3 ;
16678 int ecode3 = 0 ;
16679 unsigned char val4 ;
16680 int ecode4 = 0 ;
16681 PyObject * obj0 = 0 ;
16682 PyObject * obj1 = 0 ;
16683 PyObject * obj2 = 0 ;
16684 PyObject * obj3 = 0 ;
16685 char * kwnames[] = {
16686 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16687 };
16688
16689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16693 }
16694 arg1 = reinterpret_cast< wxImage * >(argp1);
16695 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16696 if (!SWIG_IsOK(ecode2)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16698 }
16699 arg2 = static_cast< byte >(val2);
16700 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16701 if (!SWIG_IsOK(ecode3)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16703 }
16704 arg3 = static_cast< byte >(val3);
16705 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16706 if (!SWIG_IsOK(ecode4)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16708 }
16709 arg4 = static_cast< byte >(val4);
16710 {
16711 if (!wxPyCheckForApp()) SWIG_fail;
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj = 0;
16726 wxImage *arg1 = (wxImage *) 0 ;
16727 double arg2 ;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 double val2 ;
16731 int ecode2 = 0 ;
16732 PyObject * obj0 = 0 ;
16733 PyObject * obj1 = 0 ;
16734 char * kwnames[] = {
16735 (char *) "self",(char *) "angle", NULL
16736 };
16737
16738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16740 if (!SWIG_IsOK(res1)) {
16741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16742 }
16743 arg1 = reinterpret_cast< wxImage * >(argp1);
16744 ecode2 = SWIG_AsVal_double(obj1, &val2);
16745 if (!SWIG_IsOK(ecode2)) {
16746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16747 }
16748 arg2 = static_cast< double >(val2);
16749 {
16750 PyThreadState* __tstate = wxPyBeginAllowThreads();
16751 (arg1)->RotateHue(arg2);
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 resultobj = SWIG_Py_Void();
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj = 0;
16764 wxImage_RGBValue arg1 ;
16765 wxImage_HSVValue result;
16766 void *argp1 ;
16767 int res1 = 0 ;
16768 PyObject * obj0 = 0 ;
16769 char * kwnames[] = {
16770 (char *) "rgb", NULL
16771 };
16772
16773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16774 {
16775 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16778 }
16779 if (!argp1) {
16780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16781 } else {
16782 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16783 arg1 = *temp;
16784 if (SWIG_IsNewObj(res1)) delete temp;
16785 }
16786 }
16787 {
16788 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 result = wxImage::RGBtoHSV(arg1);
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj = 0;
16802 wxImage_HSVValue arg1 ;
16803 wxImage_RGBValue result;
16804 void *argp1 ;
16805 int res1 = 0 ;
16806 PyObject * obj0 = 0 ;
16807 char * kwnames[] = {
16808 (char *) "hsv", NULL
16809 };
16810
16811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16812 {
16813 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16814 if (!SWIG_IsOK(res1)) {
16815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16816 }
16817 if (!argp1) {
16818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16819 } else {
16820 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16821 arg1 = *temp;
16822 if (SWIG_IsNewObj(res1)) delete temp;
16823 }
16824 }
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = wxImage::HSVtoRGB(arg1);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16839 PyObject *obj;
16840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16841 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16842 return SWIG_Py_Void();
16843 }
16844
16845 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16846 return SWIG_Python_InitShadowInstance(args);
16847 }
16848
16849 SWIGINTERN int NullImage_set(PyObject *) {
16850 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16851 return 1;
16852 }
16853
16854
16855 SWIGINTERN PyObject *NullImage_get(void) {
16856 PyObject *pyobj = 0;
16857
16858 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16859 return pyobj;
16860 }
16861
16862
16863 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16864 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16865 return 1;
16866 }
16867
16868
16869 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16870 PyObject *pyobj = 0;
16871
16872 {
16873 #if wxUSE_UNICODE
16874 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16875 #else
16876 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16877 #endif
16878 }
16879 return pyobj;
16880 }
16881
16882
16883 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16884 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16885 return 1;
16886 }
16887
16888
16889 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16890 PyObject *pyobj = 0;
16891
16892 {
16893 #if wxUSE_UNICODE
16894 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16895 #else
16896 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16897 #endif
16898 }
16899 return pyobj;
16900 }
16901
16902
16903 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16904 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16905 return 1;
16906 }
16907
16908
16909 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16910 PyObject *pyobj = 0;
16911
16912 {
16913 #if wxUSE_UNICODE
16914 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16915 #else
16916 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16917 #endif
16918 }
16919 return pyobj;
16920 }
16921
16922
16923 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16924 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16925 return 1;
16926 }
16927
16928
16929 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16930 PyObject *pyobj = 0;
16931
16932 {
16933 #if wxUSE_UNICODE
16934 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16935 #else
16936 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16937 #endif
16938 }
16939 return pyobj;
16940 }
16941
16942
16943 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16944 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16945 return 1;
16946 }
16947
16948
16949 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16950 PyObject *pyobj = 0;
16951
16952 {
16953 #if wxUSE_UNICODE
16954 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16955 #else
16956 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16957 #endif
16958 }
16959 return pyobj;
16960 }
16961
16962
16963 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16964 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16965 return 1;
16966 }
16967
16968
16969 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16970 PyObject *pyobj = 0;
16971
16972 {
16973 #if wxUSE_UNICODE
16974 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16975 #else
16976 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16977 #endif
16978 }
16979 return pyobj;
16980 }
16981
16982
16983 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16984 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16985 return 1;
16986 }
16987
16988
16989 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16990 PyObject *pyobj = 0;
16991
16992 {
16993 #if wxUSE_UNICODE
16994 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16995 #else
16996 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16997 #endif
16998 }
16999 return pyobj;
17000 }
17001
17002
17003 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17004 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17005 return 1;
17006 }
17007
17008
17009 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17010 PyObject *pyobj = 0;
17011
17012 {
17013 #if wxUSE_UNICODE
17014 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17015 #else
17016 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17017 #endif
17018 }
17019 return pyobj;
17020 }
17021
17022
17023 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17024 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17025 return 1;
17026 }
17027
17028
17029 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17030 PyObject *pyobj = 0;
17031
17032 {
17033 #if wxUSE_UNICODE
17034 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17035 #else
17036 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17037 #endif
17038 }
17039 return pyobj;
17040 }
17041
17042
17043 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17044 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17045 return 1;
17046 }
17047
17048
17049 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17050 PyObject *pyobj = 0;
17051
17052 {
17053 #if wxUSE_UNICODE
17054 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17055 #else
17056 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17057 #endif
17058 }
17059 return pyobj;
17060 }
17061
17062
17063 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17064 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17065 return 1;
17066 }
17067
17068
17069 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17070 PyObject *pyobj = 0;
17071
17072 {
17073 #if wxUSE_UNICODE
17074 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17075 #else
17076 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17077 #endif
17078 }
17079 return pyobj;
17080 }
17081
17082
17083 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17084 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17085 return 1;
17086 }
17087
17088
17089 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17090 PyObject *pyobj = 0;
17091
17092 {
17093 #if wxUSE_UNICODE
17094 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17095 #else
17096 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17097 #endif
17098 }
17099 return pyobj;
17100 }
17101
17102
17103 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17104 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17105 return 1;
17106 }
17107
17108
17109 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17110 PyObject *pyobj = 0;
17111
17112 {
17113 #if wxUSE_UNICODE
17114 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17115 #else
17116 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17117 #endif
17118 }
17119 return pyobj;
17120 }
17121
17122
17123 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17124 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17125 return 1;
17126 }
17127
17128
17129 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17130 PyObject *pyobj = 0;
17131
17132 {
17133 #if wxUSE_UNICODE
17134 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17135 #else
17136 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17137 #endif
17138 }
17139 return pyobj;
17140 }
17141
17142
17143 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17144 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17145 return 1;
17146 }
17147
17148
17149 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17150 PyObject *pyobj = 0;
17151
17152 {
17153 #if wxUSE_UNICODE
17154 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17155 #else
17156 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17157 #endif
17158 }
17159 return pyobj;
17160 }
17161
17162
17163 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17164 PyObject *resultobj = 0;
17165 wxBMPHandler *result = 0 ;
17166
17167 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17168 {
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 result = (wxBMPHandler *)new wxBMPHandler();
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17182 PyObject *obj;
17183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17184 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17185 return SWIG_Py_Void();
17186 }
17187
17188 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17189 return SWIG_Python_InitShadowInstance(args);
17190 }
17191
17192 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17193 PyObject *resultobj = 0;
17194 wxICOHandler *result = 0 ;
17195
17196 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17197 {
17198 PyThreadState* __tstate = wxPyBeginAllowThreads();
17199 result = (wxICOHandler *)new wxICOHandler();
17200 wxPyEndAllowThreads(__tstate);
17201 if (PyErr_Occurred()) SWIG_fail;
17202 }
17203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17211 PyObject *obj;
17212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17213 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17214 return SWIG_Py_Void();
17215 }
17216
17217 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17218 return SWIG_Python_InitShadowInstance(args);
17219 }
17220
17221 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17222 PyObject *resultobj = 0;
17223 wxCURHandler *result = 0 ;
17224
17225 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (wxCURHandler *)new wxCURHandler();
17229 wxPyEndAllowThreads(__tstate);
17230 if (PyErr_Occurred()) SWIG_fail;
17231 }
17232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17233 return resultobj;
17234 fail:
17235 return NULL;
17236 }
17237
17238
17239 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 PyObject *obj;
17241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17242 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17243 return SWIG_Py_Void();
17244 }
17245
17246 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17247 return SWIG_Python_InitShadowInstance(args);
17248 }
17249
17250 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17251 PyObject *resultobj = 0;
17252 wxANIHandler *result = 0 ;
17253
17254 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (wxANIHandler *)new wxANIHandler();
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17269 PyObject *obj;
17270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17271 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17272 return SWIG_Py_Void();
17273 }
17274
17275 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17276 return SWIG_Python_InitShadowInstance(args);
17277 }
17278
17279 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17280 PyObject *resultobj = 0;
17281 wxPNGHandler *result = 0 ;
17282
17283 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17284 {
17285 PyThreadState* __tstate = wxPyBeginAllowThreads();
17286 result = (wxPNGHandler *)new wxPNGHandler();
17287 wxPyEndAllowThreads(__tstate);
17288 if (PyErr_Occurred()) SWIG_fail;
17289 }
17290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17291 return resultobj;
17292 fail:
17293 return NULL;
17294 }
17295
17296
17297 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17298 PyObject *obj;
17299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17300 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17301 return SWIG_Py_Void();
17302 }
17303
17304 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17305 return SWIG_Python_InitShadowInstance(args);
17306 }
17307
17308 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17309 PyObject *resultobj = 0;
17310 wxGIFHandler *result = 0 ;
17311
17312 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = (wxGIFHandler *)new wxGIFHandler();
17316 wxPyEndAllowThreads(__tstate);
17317 if (PyErr_Occurred()) SWIG_fail;
17318 }
17319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17327 PyObject *obj;
17328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17329 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17330 return SWIG_Py_Void();
17331 }
17332
17333 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17334 return SWIG_Python_InitShadowInstance(args);
17335 }
17336
17337 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17338 PyObject *resultobj = 0;
17339 wxPCXHandler *result = 0 ;
17340
17341 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (wxPCXHandler *)new wxPCXHandler();
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17349 return resultobj;
17350 fail:
17351 return NULL;
17352 }
17353
17354
17355 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17356 PyObject *obj;
17357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17358 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17359 return SWIG_Py_Void();
17360 }
17361
17362 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 return SWIG_Python_InitShadowInstance(args);
17364 }
17365
17366 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17367 PyObject *resultobj = 0;
17368 wxJPEGHandler *result = 0 ;
17369
17370 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17371 {
17372 PyThreadState* __tstate = wxPyBeginAllowThreads();
17373 result = (wxJPEGHandler *)new wxJPEGHandler();
17374 wxPyEndAllowThreads(__tstate);
17375 if (PyErr_Occurred()) SWIG_fail;
17376 }
17377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 PyObject *obj;
17386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17387 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17388 return SWIG_Py_Void();
17389 }
17390
17391 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17392 return SWIG_Python_InitShadowInstance(args);
17393 }
17394
17395 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17396 PyObject *resultobj = 0;
17397 wxPNMHandler *result = 0 ;
17398
17399 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = (wxPNMHandler *)new wxPNMHandler();
17403 wxPyEndAllowThreads(__tstate);
17404 if (PyErr_Occurred()) SWIG_fail;
17405 }
17406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17407 return resultobj;
17408 fail:
17409 return NULL;
17410 }
17411
17412
17413 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17414 PyObject *obj;
17415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17416 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17417 return SWIG_Py_Void();
17418 }
17419
17420 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17421 return SWIG_Python_InitShadowInstance(args);
17422 }
17423
17424 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17425 PyObject *resultobj = 0;
17426 wxXPMHandler *result = 0 ;
17427
17428 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17429 {
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (wxXPMHandler *)new wxXPMHandler();
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 PyObject *obj;
17444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17445 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17446 return SWIG_Py_Void();
17447 }
17448
17449 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17450 return SWIG_Python_InitShadowInstance(args);
17451 }
17452
17453 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17454 PyObject *resultobj = 0;
17455 wxTIFFHandler *result = 0 ;
17456
17457 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17458 {
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (wxTIFFHandler *)new wxTIFFHandler();
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17465 return resultobj;
17466 fail:
17467 return NULL;
17468 }
17469
17470
17471 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 PyObject *obj;
17473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17474 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17475 return SWIG_Py_Void();
17476 }
17477
17478 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17479 return SWIG_Python_InitShadowInstance(args);
17480 }
17481
17482 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj = 0;
17484 wxImage *arg1 = 0 ;
17485 wxImage *arg2 = 0 ;
17486 int arg3 = (int) 236 ;
17487 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17488 bool result;
17489 void *argp1 = 0 ;
17490 int res1 = 0 ;
17491 void *argp2 = 0 ;
17492 int res2 = 0 ;
17493 int val3 ;
17494 int ecode3 = 0 ;
17495 int val4 ;
17496 int ecode4 = 0 ;
17497 PyObject * obj0 = 0 ;
17498 PyObject * obj1 = 0 ;
17499 PyObject * obj2 = 0 ;
17500 PyObject * obj3 = 0 ;
17501 char * kwnames[] = {
17502 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17503 };
17504
17505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17506 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17507 if (!SWIG_IsOK(res1)) {
17508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17509 }
17510 if (!argp1) {
17511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17512 }
17513 arg1 = reinterpret_cast< wxImage * >(argp1);
17514 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17515 if (!SWIG_IsOK(res2)) {
17516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17517 }
17518 if (!argp2) {
17519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17520 }
17521 arg2 = reinterpret_cast< wxImage * >(argp2);
17522 if (obj2) {
17523 ecode3 = SWIG_AsVal_int(obj2, &val3);
17524 if (!SWIG_IsOK(ecode3)) {
17525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17526 }
17527 arg3 = static_cast< int >(val3);
17528 }
17529 if (obj3) {
17530 ecode4 = SWIG_AsVal_int(obj3, &val4);
17531 if (!SWIG_IsOK(ecode4)) {
17532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17533 }
17534 arg4 = static_cast< int >(val4);
17535 }
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17544 }
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 PyObject *obj;
17553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17554 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17555 return SWIG_Py_Void();
17556 }
17557
17558 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 PyObject *resultobj = 0;
17560 wxEvtHandler *result = 0 ;
17561
17562 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17563 {
17564 PyThreadState* __tstate = wxPyBeginAllowThreads();
17565 result = (wxEvtHandler *)new wxEvtHandler();
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17570 return resultobj;
17571 fail:
17572 return NULL;
17573 }
17574
17575
17576 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17577 PyObject *resultobj = 0;
17578 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17579 wxEvtHandler *result = 0 ;
17580 void *argp1 = 0 ;
17581 int res1 = 0 ;
17582 PyObject *swig_obj[1] ;
17583
17584 if (!args) SWIG_fail;
17585 swig_obj[0] = args;
17586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17587 if (!SWIG_IsOK(res1)) {
17588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17589 }
17590 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = wxPyMake_wxObject(result, 0);
17599 }
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *resultobj = 0;
17608 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17609 wxEvtHandler *result = 0 ;
17610 void *argp1 = 0 ;
17611 int res1 = 0 ;
17612 PyObject *swig_obj[1] ;
17613
17614 if (!args) SWIG_fail;
17615 swig_obj[0] = args;
17616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17617 if (!SWIG_IsOK(res1)) {
17618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17619 }
17620 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17621 {
17622 PyThreadState* __tstate = wxPyBeginAllowThreads();
17623 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 {
17628 resultobj = wxPyMake_wxObject(result, 0);
17629 }
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17637 PyObject *resultobj = 0;
17638 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17639 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17640 void *argp1 = 0 ;
17641 int res1 = 0 ;
17642 void *argp2 = 0 ;
17643 int res2 = 0 ;
17644 PyObject * obj0 = 0 ;
17645 PyObject * obj1 = 0 ;
17646 char * kwnames[] = {
17647 (char *) "self",(char *) "handler", NULL
17648 };
17649
17650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17652 if (!SWIG_IsOK(res1)) {
17653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17654 }
17655 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17657 if (!SWIG_IsOK(res2)) {
17658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17659 }
17660 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 (arg1)->SetNextHandler(arg2);
17664 wxPyEndAllowThreads(__tstate);
17665 if (PyErr_Occurred()) SWIG_fail;
17666 }
17667 resultobj = SWIG_Py_Void();
17668 return resultobj;
17669 fail:
17670 return NULL;
17671 }
17672
17673
17674 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17675 PyObject *resultobj = 0;
17676 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17677 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17678 void *argp1 = 0 ;
17679 int res1 = 0 ;
17680 void *argp2 = 0 ;
17681 int res2 = 0 ;
17682 PyObject * obj0 = 0 ;
17683 PyObject * obj1 = 0 ;
17684 char * kwnames[] = {
17685 (char *) "self",(char *) "handler", NULL
17686 };
17687
17688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17690 if (!SWIG_IsOK(res1)) {
17691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17692 }
17693 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17695 if (!SWIG_IsOK(res2)) {
17696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17697 }
17698 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 (arg1)->SetPreviousHandler(arg2);
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_Py_Void();
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *resultobj = 0;
17714 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17715 bool result;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 PyObject *swig_obj[1] ;
17719
17720 if (!args) SWIG_fail;
17721 swig_obj[0] = args;
17722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17723 if (!SWIG_IsOK(res1)) {
17724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17725 }
17726 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->GetEvtHandlerEnabled();
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 {
17734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17735 }
17736 return resultobj;
17737 fail:
17738 return NULL;
17739 }
17740
17741
17742 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17743 PyObject *resultobj = 0;
17744 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17745 bool arg2 ;
17746 void *argp1 = 0 ;
17747 int res1 = 0 ;
17748 bool val2 ;
17749 int ecode2 = 0 ;
17750 PyObject * obj0 = 0 ;
17751 PyObject * obj1 = 0 ;
17752 char * kwnames[] = {
17753 (char *) "self",(char *) "enabled", NULL
17754 };
17755
17756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17758 if (!SWIG_IsOK(res1)) {
17759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17760 }
17761 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17763 if (!SWIG_IsOK(ecode2)) {
17764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17765 }
17766 arg2 = static_cast< bool >(val2);
17767 {
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 (arg1)->SetEvtHandlerEnabled(arg2);
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 resultobj = SWIG_Py_Void();
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17781 PyObject *resultobj = 0;
17782 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17783 wxEvent *arg2 = 0 ;
17784 bool result;
17785 void *argp1 = 0 ;
17786 int res1 = 0 ;
17787 void *argp2 = 0 ;
17788 int res2 = 0 ;
17789 PyObject * obj0 = 0 ;
17790 PyObject * obj1 = 0 ;
17791 char * kwnames[] = {
17792 (char *) "self",(char *) "event", NULL
17793 };
17794
17795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17797 if (!SWIG_IsOK(res1)) {
17798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17799 }
17800 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17802 if (!SWIG_IsOK(res2)) {
17803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17804 }
17805 if (!argp2) {
17806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17807 }
17808 arg2 = reinterpret_cast< wxEvent * >(argp2);
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)(arg1)->ProcessEvent(*arg2);
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 return resultobj;
17819 fail:
17820 return NULL;
17821 }
17822
17823
17824 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17825 PyObject *resultobj = 0;
17826 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17827 wxEvent *arg2 = 0 ;
17828 void *argp1 = 0 ;
17829 int res1 = 0 ;
17830 void *argp2 = 0 ;
17831 int res2 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char * kwnames[] = {
17835 (char *) "self",(char *) "event", NULL
17836 };
17837
17838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17842 }
17843 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17844 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17845 if (!SWIG_IsOK(res2)) {
17846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17847 }
17848 if (!argp2) {
17849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17850 }
17851 arg2 = reinterpret_cast< wxEvent * >(argp2);
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 (arg1)->AddPendingEvent(*arg2);
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 resultobj = SWIG_Py_Void();
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17866 PyObject *resultobj = 0;
17867 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17868 void *argp1 = 0 ;
17869 int res1 = 0 ;
17870 PyObject *swig_obj[1] ;
17871
17872 if (!args) SWIG_fail;
17873 swig_obj[0] = args;
17874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17875 if (!SWIG_IsOK(res1)) {
17876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17877 }
17878 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 (arg1)->ProcessPendingEvents();
17882 wxPyEndAllowThreads(__tstate);
17883 if (PyErr_Occurred()) SWIG_fail;
17884 }
17885 resultobj = SWIG_Py_Void();
17886 return resultobj;
17887 fail:
17888 return NULL;
17889 }
17890
17891
17892 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17893 PyObject *resultobj = 0;
17894 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17895 int arg2 ;
17896 int arg3 ;
17897 int arg4 ;
17898 PyObject *arg5 = (PyObject *) 0 ;
17899 void *argp1 = 0 ;
17900 int res1 = 0 ;
17901 int val2 ;
17902 int ecode2 = 0 ;
17903 int val3 ;
17904 int ecode3 = 0 ;
17905 int val4 ;
17906 int ecode4 = 0 ;
17907 PyObject * obj0 = 0 ;
17908 PyObject * obj1 = 0 ;
17909 PyObject * obj2 = 0 ;
17910 PyObject * obj3 = 0 ;
17911 PyObject * obj4 = 0 ;
17912 char * kwnames[] = {
17913 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17914 };
17915
17916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17918 if (!SWIG_IsOK(res1)) {
17919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17920 }
17921 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17922 ecode2 = SWIG_AsVal_int(obj1, &val2);
17923 if (!SWIG_IsOK(ecode2)) {
17924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17925 }
17926 arg2 = static_cast< int >(val2);
17927 ecode3 = SWIG_AsVal_int(obj2, &val3);
17928 if (!SWIG_IsOK(ecode3)) {
17929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17930 }
17931 arg3 = static_cast< int >(val3);
17932 ecode4 = SWIG_AsVal_int(obj3, &val4);
17933 if (!SWIG_IsOK(ecode4)) {
17934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17935 }
17936 arg4 = static_cast< int >(val4);
17937 arg5 = obj4;
17938 {
17939 PyThreadState* __tstate = wxPyBeginAllowThreads();
17940 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 resultobj = SWIG_Py_Void();
17945 return resultobj;
17946 fail:
17947 return NULL;
17948 }
17949
17950
17951 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17952 PyObject *resultobj = 0;
17953 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17954 int arg2 ;
17955 int arg3 = (int) -1 ;
17956 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17957 bool result;
17958 void *argp1 = 0 ;
17959 int res1 = 0 ;
17960 int val2 ;
17961 int ecode2 = 0 ;
17962 int val3 ;
17963 int ecode3 = 0 ;
17964 int val4 ;
17965 int ecode4 = 0 ;
17966 PyObject * obj0 = 0 ;
17967 PyObject * obj1 = 0 ;
17968 PyObject * obj2 = 0 ;
17969 PyObject * obj3 = 0 ;
17970 char * kwnames[] = {
17971 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17972 };
17973
17974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17978 }
17979 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17980 ecode2 = SWIG_AsVal_int(obj1, &val2);
17981 if (!SWIG_IsOK(ecode2)) {
17982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17983 }
17984 arg2 = static_cast< int >(val2);
17985 if (obj2) {
17986 ecode3 = SWIG_AsVal_int(obj2, &val3);
17987 if (!SWIG_IsOK(ecode3)) {
17988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17989 }
17990 arg3 = static_cast< int >(val3);
17991 }
17992 if (obj3) {
17993 ecode4 = SWIG_AsVal_int(obj3, &val4);
17994 if (!SWIG_IsOK(ecode4)) {
17995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17996 }
17997 arg4 = static_cast< wxEventType >(val4);
17998 }
17999 {
18000 PyThreadState* __tstate = wxPyBeginAllowThreads();
18001 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18002 wxPyEndAllowThreads(__tstate);
18003 if (PyErr_Occurred()) SWIG_fail;
18004 }
18005 {
18006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj = 0;
18016 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18017 PyObject *arg2 = (PyObject *) 0 ;
18018 bool arg3 = (bool) true ;
18019 void *argp1 = 0 ;
18020 int res1 = 0 ;
18021 bool val3 ;
18022 int ecode3 = 0 ;
18023 PyObject * obj0 = 0 ;
18024 PyObject * obj1 = 0 ;
18025 PyObject * obj2 = 0 ;
18026 char * kwnames[] = {
18027 (char *) "self",(char *) "_self",(char *) "incref", NULL
18028 };
18029
18030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18032 if (!SWIG_IsOK(res1)) {
18033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18034 }
18035 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18036 arg2 = obj1;
18037 if (obj2) {
18038 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18039 if (!SWIG_IsOK(ecode3)) {
18040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18041 }
18042 arg3 = static_cast< bool >(val3);
18043 }
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 resultobj = SWIG_Py_Void();
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18058 PyObject *obj;
18059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18060 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18061 return SWIG_Py_Void();
18062 }
18063
18064 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 return SWIG_Python_InitShadowInstance(args);
18066 }
18067
18068 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18069 PyObject *resultobj = 0;
18070 wxEventType result;
18071
18072 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (wxEventType)wxNewEventType();
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = SWIG_From_int(static_cast< int >(result));
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 PyObject *resultobj = 0;
18088 wxEvent *arg1 = (wxEvent *) 0 ;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 PyObject *swig_obj[1] ;
18092
18093 if (!args) SWIG_fail;
18094 swig_obj[0] = args;
18095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18096 if (!SWIG_IsOK(res1)) {
18097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18098 }
18099 arg1 = reinterpret_cast< wxEvent * >(argp1);
18100 {
18101 PyThreadState* __tstate = wxPyBeginAllowThreads();
18102 delete arg1;
18103
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = SWIG_Py_Void();
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18115 PyObject *resultobj = 0;
18116 wxEvent *arg1 = (wxEvent *) 0 ;
18117 wxEventType arg2 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 int val2 ;
18121 int ecode2 = 0 ;
18122 PyObject * obj0 = 0 ;
18123 PyObject * obj1 = 0 ;
18124 char * kwnames[] = {
18125 (char *) "self",(char *) "typ", NULL
18126 };
18127
18128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18130 if (!SWIG_IsOK(res1)) {
18131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18132 }
18133 arg1 = reinterpret_cast< wxEvent * >(argp1);
18134 ecode2 = SWIG_AsVal_int(obj1, &val2);
18135 if (!SWIG_IsOK(ecode2)) {
18136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18137 }
18138 arg2 = static_cast< wxEventType >(val2);
18139 {
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 (arg1)->SetEventType(arg2);
18142 wxPyEndAllowThreads(__tstate);
18143 if (PyErr_Occurred()) SWIG_fail;
18144 }
18145 resultobj = SWIG_Py_Void();
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18153 PyObject *resultobj = 0;
18154 wxEvent *arg1 = (wxEvent *) 0 ;
18155 wxEventType result;
18156 void *argp1 = 0 ;
18157 int res1 = 0 ;
18158 PyObject *swig_obj[1] ;
18159
18160 if (!args) SWIG_fail;
18161 swig_obj[0] = args;
18162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18165 }
18166 arg1 = reinterpret_cast< wxEvent * >(argp1);
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 resultobj = SWIG_From_int(static_cast< int >(result));
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18181 PyObject *resultobj = 0;
18182 wxEvent *arg1 = (wxEvent *) 0 ;
18183 wxObject *result = 0 ;
18184 void *argp1 = 0 ;
18185 int res1 = 0 ;
18186 PyObject *swig_obj[1] ;
18187
18188 if (!args) SWIG_fail;
18189 swig_obj[0] = args;
18190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18191 if (!SWIG_IsOK(res1)) {
18192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18193 }
18194 arg1 = reinterpret_cast< wxEvent * >(argp1);
18195 {
18196 PyThreadState* __tstate = wxPyBeginAllowThreads();
18197 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18198 wxPyEndAllowThreads(__tstate);
18199 if (PyErr_Occurred()) SWIG_fail;
18200 }
18201 {
18202 resultobj = wxPyMake_wxObject(result, (bool)0);
18203 }
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj = 0;
18212 wxEvent *arg1 = (wxEvent *) 0 ;
18213 wxObject *arg2 = (wxObject *) 0 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 void *argp2 = 0 ;
18217 int res2 = 0 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char * kwnames[] = {
18221 (char *) "self",(char *) "obj", NULL
18222 };
18223
18224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18231 if (!SWIG_IsOK(res2)) {
18232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18233 }
18234 arg2 = reinterpret_cast< wxObject * >(argp2);
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 (arg1)->SetEventObject(arg2);
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 resultobj = SWIG_Py_Void();
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18249 PyObject *resultobj = 0;
18250 wxEvent *arg1 = (wxEvent *) 0 ;
18251 long result;
18252 void *argp1 = 0 ;
18253 int res1 = 0 ;
18254 PyObject *swig_obj[1] ;
18255
18256 if (!args) SWIG_fail;
18257 swig_obj[0] = args;
18258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18259 if (!SWIG_IsOK(res1)) {
18260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18261 }
18262 arg1 = reinterpret_cast< wxEvent * >(argp1);
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = SWIG_From_long(static_cast< long >(result));
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj = 0;
18278 wxEvent *arg1 = (wxEvent *) 0 ;
18279 long arg2 = (long) 0 ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 long val2 ;
18283 int ecode2 = 0 ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 char * kwnames[] = {
18287 (char *) "self",(char *) "ts", NULL
18288 };
18289
18290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18292 if (!SWIG_IsOK(res1)) {
18293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18294 }
18295 arg1 = reinterpret_cast< wxEvent * >(argp1);
18296 if (obj1) {
18297 ecode2 = SWIG_AsVal_long(obj1, &val2);
18298 if (!SWIG_IsOK(ecode2)) {
18299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18300 }
18301 arg2 = static_cast< long >(val2);
18302 }
18303 {
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 (arg1)->SetTimestamp(arg2);
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 resultobj = SWIG_Py_Void();
18310 return resultobj;
18311 fail:
18312 return NULL;
18313 }
18314
18315
18316 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18317 PyObject *resultobj = 0;
18318 wxEvent *arg1 = (wxEvent *) 0 ;
18319 int result;
18320 void *argp1 = 0 ;
18321 int res1 = 0 ;
18322 PyObject *swig_obj[1] ;
18323
18324 if (!args) SWIG_fail;
18325 swig_obj[0] = args;
18326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18327 if (!SWIG_IsOK(res1)) {
18328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18329 }
18330 arg1 = reinterpret_cast< wxEvent * >(argp1);
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (int)((wxEvent const *)arg1)->GetId();
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 resultobj = SWIG_From_int(static_cast< int >(result));
18338 return resultobj;
18339 fail:
18340 return NULL;
18341 }
18342
18343
18344 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18345 PyObject *resultobj = 0;
18346 wxEvent *arg1 = (wxEvent *) 0 ;
18347 int arg2 ;
18348 void *argp1 = 0 ;
18349 int res1 = 0 ;
18350 int val2 ;
18351 int ecode2 = 0 ;
18352 PyObject * obj0 = 0 ;
18353 PyObject * obj1 = 0 ;
18354 char * kwnames[] = {
18355 (char *) "self",(char *) "Id", NULL
18356 };
18357
18358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18360 if (!SWIG_IsOK(res1)) {
18361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18362 }
18363 arg1 = reinterpret_cast< wxEvent * >(argp1);
18364 ecode2 = SWIG_AsVal_int(obj1, &val2);
18365 if (!SWIG_IsOK(ecode2)) {
18366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18367 }
18368 arg2 = static_cast< int >(val2);
18369 {
18370 PyThreadState* __tstate = wxPyBeginAllowThreads();
18371 (arg1)->SetId(arg2);
18372 wxPyEndAllowThreads(__tstate);
18373 if (PyErr_Occurred()) SWIG_fail;
18374 }
18375 resultobj = SWIG_Py_Void();
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18383 PyObject *resultobj = 0;
18384 wxEvent *arg1 = (wxEvent *) 0 ;
18385 bool result;
18386 void *argp1 = 0 ;
18387 int res1 = 0 ;
18388 PyObject *swig_obj[1] ;
18389
18390 if (!args) SWIG_fail;
18391 swig_obj[0] = args;
18392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18393 if (!SWIG_IsOK(res1)) {
18394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18395 }
18396 arg1 = reinterpret_cast< wxEvent * >(argp1);
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 {
18404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj = 0;
18414 wxEvent *arg1 = (wxEvent *) 0 ;
18415 bool arg2 = (bool) true ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 bool val2 ;
18419 int ecode2 = 0 ;
18420 PyObject * obj0 = 0 ;
18421 PyObject * obj1 = 0 ;
18422 char * kwnames[] = {
18423 (char *) "self",(char *) "skip", NULL
18424 };
18425
18426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18428 if (!SWIG_IsOK(res1)) {
18429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18430 }
18431 arg1 = reinterpret_cast< wxEvent * >(argp1);
18432 if (obj1) {
18433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18434 if (!SWIG_IsOK(ecode2)) {
18435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18436 }
18437 arg2 = static_cast< bool >(val2);
18438 }
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 (arg1)->Skip(arg2);
18442 wxPyEndAllowThreads(__tstate);
18443 if (PyErr_Occurred()) SWIG_fail;
18444 }
18445 resultobj = SWIG_Py_Void();
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18453 PyObject *resultobj = 0;
18454 wxEvent *arg1 = (wxEvent *) 0 ;
18455 bool result;
18456 void *argp1 = 0 ;
18457 int res1 = 0 ;
18458 PyObject *swig_obj[1] ;
18459
18460 if (!args) SWIG_fail;
18461 swig_obj[0] = args;
18462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18463 if (!SWIG_IsOK(res1)) {
18464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18465 }
18466 arg1 = reinterpret_cast< wxEvent * >(argp1);
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18470 wxPyEndAllowThreads(__tstate);
18471 if (PyErr_Occurred()) SWIG_fail;
18472 }
18473 {
18474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18475 }
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483 PyObject *resultobj = 0;
18484 wxEvent *arg1 = (wxEvent *) 0 ;
18485 bool result;
18486 void *argp1 = 0 ;
18487 int res1 = 0 ;
18488 PyObject *swig_obj[1] ;
18489
18490 if (!args) SWIG_fail;
18491 swig_obj[0] = args;
18492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18493 if (!SWIG_IsOK(res1)) {
18494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18495 }
18496 arg1 = reinterpret_cast< wxEvent * >(argp1);
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 {
18504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18505 }
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 int result;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18525 }
18526 arg1 = reinterpret_cast< wxEvent * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (int)(arg1)->StopPropagation();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 resultobj = SWIG_From_int(static_cast< int >(result));
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj = 0;
18542 wxEvent *arg1 = (wxEvent *) 0 ;
18543 int arg2 ;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 int val2 ;
18547 int ecode2 = 0 ;
18548 PyObject * obj0 = 0 ;
18549 PyObject * obj1 = 0 ;
18550 char * kwnames[] = {
18551 (char *) "self",(char *) "propagationLevel", NULL
18552 };
18553
18554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18556 if (!SWIG_IsOK(res1)) {
18557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18558 }
18559 arg1 = reinterpret_cast< wxEvent * >(argp1);
18560 ecode2 = SWIG_AsVal_int(obj1, &val2);
18561 if (!SWIG_IsOK(ecode2)) {
18562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18563 }
18564 arg2 = static_cast< int >(val2);
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 (arg1)->ResumePropagation(arg2);
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 resultobj = SWIG_Py_Void();
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18579 PyObject *resultobj = 0;
18580 wxEvent *arg1 = (wxEvent *) 0 ;
18581 wxEvent *result = 0 ;
18582 void *argp1 = 0 ;
18583 int res1 = 0 ;
18584 PyObject *swig_obj[1] ;
18585
18586 if (!args) SWIG_fail;
18587 swig_obj[0] = args;
18588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18589 if (!SWIG_IsOK(res1)) {
18590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18591 }
18592 arg1 = reinterpret_cast< wxEvent * >(argp1);
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (wxEvent *)(arg1)->Clone();
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 PyObject *obj;
18608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18609 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18610 return SWIG_Py_Void();
18611 }
18612
18613 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18614 PyObject *resultobj = 0;
18615 wxEvent *arg1 = 0 ;
18616 wxPropagationDisabler *result = 0 ;
18617 void *argp1 = 0 ;
18618 int res1 = 0 ;
18619 PyObject * obj0 = 0 ;
18620 char * kwnames[] = {
18621 (char *) "event", NULL
18622 };
18623
18624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18625 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18626 if (!SWIG_IsOK(res1)) {
18627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18628 }
18629 if (!argp1) {
18630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18631 }
18632 arg1 = reinterpret_cast< wxEvent * >(argp1);
18633 {
18634 PyThreadState* __tstate = wxPyBeginAllowThreads();
18635 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18636 wxPyEndAllowThreads(__tstate);
18637 if (PyErr_Occurred()) SWIG_fail;
18638 }
18639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18640 return resultobj;
18641 fail:
18642 return NULL;
18643 }
18644
18645
18646 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18647 PyObject *resultobj = 0;
18648 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18649 void *argp1 = 0 ;
18650 int res1 = 0 ;
18651 PyObject *swig_obj[1] ;
18652
18653 if (!args) SWIG_fail;
18654 swig_obj[0] = args;
18655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18656 if (!SWIG_IsOK(res1)) {
18657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18658 }
18659 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 delete arg1;
18663
18664 wxPyEndAllowThreads(__tstate);
18665 if (PyErr_Occurred()) SWIG_fail;
18666 }
18667 resultobj = SWIG_Py_Void();
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18675 PyObject *obj;
18676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18677 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18678 return SWIG_Py_Void();
18679 }
18680
18681 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18682 return SWIG_Python_InitShadowInstance(args);
18683 }
18684
18685 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18686 PyObject *resultobj = 0;
18687 wxEvent *arg1 = 0 ;
18688 wxPropagateOnce *result = 0 ;
18689 void *argp1 = 0 ;
18690 int res1 = 0 ;
18691 PyObject * obj0 = 0 ;
18692 char * kwnames[] = {
18693 (char *) "event", NULL
18694 };
18695
18696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18697 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18698 if (!SWIG_IsOK(res1)) {
18699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18700 }
18701 if (!argp1) {
18702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18703 }
18704 arg1 = reinterpret_cast< wxEvent * >(argp1);
18705 {
18706 PyThreadState* __tstate = wxPyBeginAllowThreads();
18707 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18708 wxPyEndAllowThreads(__tstate);
18709 if (PyErr_Occurred()) SWIG_fail;
18710 }
18711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18719 PyObject *resultobj = 0;
18720 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18721 void *argp1 = 0 ;
18722 int res1 = 0 ;
18723 PyObject *swig_obj[1] ;
18724
18725 if (!args) SWIG_fail;
18726 swig_obj[0] = args;
18727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18728 if (!SWIG_IsOK(res1)) {
18729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18730 }
18731 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 delete arg1;
18735
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 resultobj = SWIG_Py_Void();
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18747 PyObject *obj;
18748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18749 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18750 return SWIG_Py_Void();
18751 }
18752
18753 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18754 return SWIG_Python_InitShadowInstance(args);
18755 }
18756
18757 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj = 0;
18759 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18760 int arg2 = (int) 0 ;
18761 wxCommandEvent *result = 0 ;
18762 int val1 ;
18763 int ecode1 = 0 ;
18764 int val2 ;
18765 int ecode2 = 0 ;
18766 PyObject * obj0 = 0 ;
18767 PyObject * obj1 = 0 ;
18768 char * kwnames[] = {
18769 (char *) "commandType",(char *) "winid", NULL
18770 };
18771
18772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18773 if (obj0) {
18774 ecode1 = SWIG_AsVal_int(obj0, &val1);
18775 if (!SWIG_IsOK(ecode1)) {
18776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18777 }
18778 arg1 = static_cast< wxEventType >(val1);
18779 }
18780 if (obj1) {
18781 ecode2 = SWIG_AsVal_int(obj1, &val2);
18782 if (!SWIG_IsOK(ecode2)) {
18783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18784 }
18785 arg2 = static_cast< int >(val2);
18786 }
18787 {
18788 PyThreadState* __tstate = wxPyBeginAllowThreads();
18789 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18801 PyObject *resultobj = 0;
18802 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18803 int result;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 PyObject *swig_obj[1] ;
18807
18808 if (!args) SWIG_fail;
18809 swig_obj[0] = args;
18810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18811 if (!SWIG_IsOK(res1)) {
18812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18813 }
18814 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18815 {
18816 PyThreadState* __tstate = wxPyBeginAllowThreads();
18817 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 resultobj = SWIG_From_int(static_cast< int >(result));
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj = 0;
18830 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18831 wxString *arg2 = 0 ;
18832 void *argp1 = 0 ;
18833 int res1 = 0 ;
18834 bool temp2 = false ;
18835 PyObject * obj0 = 0 ;
18836 PyObject * obj1 = 0 ;
18837 char * kwnames[] = {
18838 (char *) "self",(char *) "s", NULL
18839 };
18840
18841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18845 }
18846 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18847 {
18848 arg2 = wxString_in_helper(obj1);
18849 if (arg2 == NULL) SWIG_fail;
18850 temp2 = true;
18851 }
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 (arg1)->SetString((wxString const &)*arg2);
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 resultobj = SWIG_Py_Void();
18859 {
18860 if (temp2)
18861 delete arg2;
18862 }
18863 return resultobj;
18864 fail:
18865 {
18866 if (temp2)
18867 delete arg2;
18868 }
18869 return NULL;
18870 }
18871
18872
18873 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18874 PyObject *resultobj = 0;
18875 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18876 wxString result;
18877 void *argp1 = 0 ;
18878 int res1 = 0 ;
18879 PyObject *swig_obj[1] ;
18880
18881 if (!args) SWIG_fail;
18882 swig_obj[0] = args;
18883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18884 if (!SWIG_IsOK(res1)) {
18885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18886 }
18887 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18888 {
18889 PyThreadState* __tstate = wxPyBeginAllowThreads();
18890 result = ((wxCommandEvent const *)arg1)->GetString();
18891 wxPyEndAllowThreads(__tstate);
18892 if (PyErr_Occurred()) SWIG_fail;
18893 }
18894 {
18895 #if wxUSE_UNICODE
18896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18897 #else
18898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18899 #endif
18900 }
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *resultobj = 0;
18909 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18910 bool result;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 PyObject *swig_obj[1] ;
18914
18915 if (!args) SWIG_fail;
18916 swig_obj[0] = args;
18917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18918 if (!SWIG_IsOK(res1)) {
18919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18920 }
18921 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 {
18929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18930 }
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18938 PyObject *resultobj = 0;
18939 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18940 bool result;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 PyObject *swig_obj[1] ;
18944
18945 if (!args) SWIG_fail;
18946 swig_obj[0] = args;
18947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18948 if (!SWIG_IsOK(res1)) {
18949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18950 }
18951 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 {
18959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18960 }
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj = 0;
18969 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18970 long arg2 ;
18971 void *argp1 = 0 ;
18972 int res1 = 0 ;
18973 long val2 ;
18974 int ecode2 = 0 ;
18975 PyObject * obj0 = 0 ;
18976 PyObject * obj1 = 0 ;
18977 char * kwnames[] = {
18978 (char *) "self",(char *) "extraLong", NULL
18979 };
18980
18981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18985 }
18986 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18987 ecode2 = SWIG_AsVal_long(obj1, &val2);
18988 if (!SWIG_IsOK(ecode2)) {
18989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18990 }
18991 arg2 = static_cast< long >(val2);
18992 {
18993 PyThreadState* __tstate = wxPyBeginAllowThreads();
18994 (arg1)->SetExtraLong(arg2);
18995 wxPyEndAllowThreads(__tstate);
18996 if (PyErr_Occurred()) SWIG_fail;
18997 }
18998 resultobj = SWIG_Py_Void();
18999 return resultobj;
19000 fail:
19001 return NULL;
19002 }
19003
19004
19005 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19006 PyObject *resultobj = 0;
19007 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19008 long result;
19009 void *argp1 = 0 ;
19010 int res1 = 0 ;
19011 PyObject *swig_obj[1] ;
19012
19013 if (!args) SWIG_fail;
19014 swig_obj[0] = args;
19015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19016 if (!SWIG_IsOK(res1)) {
19017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19018 }
19019 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_From_long(static_cast< long >(result));
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19034 PyObject *resultobj = 0;
19035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19036 int arg2 ;
19037 void *argp1 = 0 ;
19038 int res1 = 0 ;
19039 int val2 ;
19040 int ecode2 = 0 ;
19041 PyObject * obj0 = 0 ;
19042 PyObject * obj1 = 0 ;
19043 char * kwnames[] = {
19044 (char *) "self",(char *) "i", NULL
19045 };
19046
19047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19051 }
19052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19053 ecode2 = SWIG_AsVal_int(obj1, &val2);
19054 if (!SWIG_IsOK(ecode2)) {
19055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19056 }
19057 arg2 = static_cast< int >(val2);
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 (arg1)->SetInt(arg2);
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_Py_Void();
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19072 PyObject *resultobj = 0;
19073 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19074 long result;
19075 void *argp1 = 0 ;
19076 int res1 = 0 ;
19077 PyObject *swig_obj[1] ;
19078
19079 if (!args) SWIG_fail;
19080 swig_obj[0] = args;
19081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19082 if (!SWIG_IsOK(res1)) {
19083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19084 }
19085 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19086 {
19087 PyThreadState* __tstate = wxPyBeginAllowThreads();
19088 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 resultobj = SWIG_From_long(static_cast< long >(result));
19093 return resultobj;
19094 fail:
19095 return NULL;
19096 }
19097
19098
19099 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19100 PyObject *resultobj = 0;
19101 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19102 PyObject *result = 0 ;
19103 void *argp1 = 0 ;
19104 int res1 = 0 ;
19105 PyObject *swig_obj[1] ;
19106
19107 if (!args) SWIG_fail;
19108 swig_obj[0] = args;
19109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19112 }
19113 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = result;
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19128 PyObject *resultobj = 0;
19129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19130 PyObject *arg2 = (PyObject *) 0 ;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject * obj0 = 0 ;
19134 PyObject * obj1 = 0 ;
19135 char * kwnames[] = {
19136 (char *) "self",(char *) "clientData", NULL
19137 };
19138
19139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19141 if (!SWIG_IsOK(res1)) {
19142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19143 }
19144 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19145 arg2 = obj1;
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 wxCommandEvent_SetClientData(arg1,arg2);
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 resultobj = SWIG_Py_Void();
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19162 wxEvent *result = 0 ;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19172 }
19173 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19188 PyObject *obj;
19189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19190 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19191 return SWIG_Py_Void();
19192 }
19193
19194 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19195 return SWIG_Python_InitShadowInstance(args);
19196 }
19197
19198 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19199 PyObject *resultobj = 0;
19200 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19201 int arg2 = (int) 0 ;
19202 wxNotifyEvent *result = 0 ;
19203 int val1 ;
19204 int ecode1 = 0 ;
19205 int val2 ;
19206 int ecode2 = 0 ;
19207 PyObject * obj0 = 0 ;
19208 PyObject * obj1 = 0 ;
19209 char * kwnames[] = {
19210 (char *) "commandType",(char *) "winid", NULL
19211 };
19212
19213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19214 if (obj0) {
19215 ecode1 = SWIG_AsVal_int(obj0, &val1);
19216 if (!SWIG_IsOK(ecode1)) {
19217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19218 }
19219 arg1 = static_cast< wxEventType >(val1);
19220 }
19221 if (obj1) {
19222 ecode2 = SWIG_AsVal_int(obj1, &val2);
19223 if (!SWIG_IsOK(ecode2)) {
19224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19225 }
19226 arg2 = static_cast< int >(val2);
19227 }
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19242 PyObject *resultobj = 0;
19243 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19244 void *argp1 = 0 ;
19245 int res1 = 0 ;
19246 PyObject *swig_obj[1] ;
19247
19248 if (!args) SWIG_fail;
19249 swig_obj[0] = args;
19250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19251 if (!SWIG_IsOK(res1)) {
19252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19253 }
19254 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19255 {
19256 PyThreadState* __tstate = wxPyBeginAllowThreads();
19257 (arg1)->Veto();
19258 wxPyEndAllowThreads(__tstate);
19259 if (PyErr_Occurred()) SWIG_fail;
19260 }
19261 resultobj = SWIG_Py_Void();
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19269 PyObject *resultobj = 0;
19270 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19271 void *argp1 = 0 ;
19272 int res1 = 0 ;
19273 PyObject *swig_obj[1] ;
19274
19275 if (!args) SWIG_fail;
19276 swig_obj[0] = args;
19277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19278 if (!SWIG_IsOK(res1)) {
19279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19280 }
19281 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 (arg1)->Allow();
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 resultobj = SWIG_Py_Void();
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19296 PyObject *resultobj = 0;
19297 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19298 bool result;
19299 void *argp1 = 0 ;
19300 int res1 = 0 ;
19301 PyObject *swig_obj[1] ;
19302
19303 if (!args) SWIG_fail;
19304 swig_obj[0] = args;
19305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19306 if (!SWIG_IsOK(res1)) {
19307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19308 }
19309 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = (bool)(arg1)->IsAllowed();
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 {
19317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19318 }
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 PyObject *obj;
19327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19328 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19329 return SWIG_Py_Void();
19330 }
19331
19332 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 return SWIG_Python_InitShadowInstance(args);
19334 }
19335
19336 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19337 PyObject *resultobj = 0;
19338 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19339 int arg2 = (int) 0 ;
19340 int arg3 = (int) 0 ;
19341 int arg4 = (int) 0 ;
19342 wxScrollEvent *result = 0 ;
19343 int val1 ;
19344 int ecode1 = 0 ;
19345 int val2 ;
19346 int ecode2 = 0 ;
19347 int val3 ;
19348 int ecode3 = 0 ;
19349 int val4 ;
19350 int ecode4 = 0 ;
19351 PyObject * obj0 = 0 ;
19352 PyObject * obj1 = 0 ;
19353 PyObject * obj2 = 0 ;
19354 PyObject * obj3 = 0 ;
19355 char * kwnames[] = {
19356 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19357 };
19358
19359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19360 if (obj0) {
19361 ecode1 = SWIG_AsVal_int(obj0, &val1);
19362 if (!SWIG_IsOK(ecode1)) {
19363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19364 }
19365 arg1 = static_cast< wxEventType >(val1);
19366 }
19367 if (obj1) {
19368 ecode2 = SWIG_AsVal_int(obj1, &val2);
19369 if (!SWIG_IsOK(ecode2)) {
19370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19371 }
19372 arg2 = static_cast< int >(val2);
19373 }
19374 if (obj2) {
19375 ecode3 = SWIG_AsVal_int(obj2, &val3);
19376 if (!SWIG_IsOK(ecode3)) {
19377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19378 }
19379 arg3 = static_cast< int >(val3);
19380 }
19381 if (obj3) {
19382 ecode4 = SWIG_AsVal_int(obj3, &val4);
19383 if (!SWIG_IsOK(ecode4)) {
19384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19385 }
19386 arg4 = static_cast< int >(val4);
19387 }
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19395 return resultobj;
19396 fail:
19397 return NULL;
19398 }
19399
19400
19401 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19402 PyObject *resultobj = 0;
19403 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19404 int result;
19405 void *argp1 = 0 ;
19406 int res1 = 0 ;
19407 PyObject *swig_obj[1] ;
19408
19409 if (!args) SWIG_fail;
19410 swig_obj[0] = args;
19411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19412 if (!SWIG_IsOK(res1)) {
19413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19414 }
19415 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = SWIG_From_int(static_cast< int >(result));
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19430 PyObject *resultobj = 0;
19431 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19432 int result;
19433 void *argp1 = 0 ;
19434 int res1 = 0 ;
19435 PyObject *swig_obj[1] ;
19436
19437 if (!args) SWIG_fail;
19438 swig_obj[0] = args;
19439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19440 if (!SWIG_IsOK(res1)) {
19441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19442 }
19443 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_From_int(static_cast< int >(result));
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj = 0;
19459 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19460 int arg2 ;
19461 void *argp1 = 0 ;
19462 int res1 = 0 ;
19463 int val2 ;
19464 int ecode2 = 0 ;
19465 PyObject * obj0 = 0 ;
19466 PyObject * obj1 = 0 ;
19467 char * kwnames[] = {
19468 (char *) "self",(char *) "orient", NULL
19469 };
19470
19471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19473 if (!SWIG_IsOK(res1)) {
19474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19475 }
19476 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19477 ecode2 = SWIG_AsVal_int(obj1, &val2);
19478 if (!SWIG_IsOK(ecode2)) {
19479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19480 }
19481 arg2 = static_cast< int >(val2);
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 (arg1)->SetOrientation(arg2);
19485 wxPyEndAllowThreads(__tstate);
19486 if (PyErr_Occurred()) SWIG_fail;
19487 }
19488 resultobj = SWIG_Py_Void();
19489 return resultobj;
19490 fail:
19491 return NULL;
19492 }
19493
19494
19495 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19496 PyObject *resultobj = 0;
19497 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19498 int arg2 ;
19499 void *argp1 = 0 ;
19500 int res1 = 0 ;
19501 int val2 ;
19502 int ecode2 = 0 ;
19503 PyObject * obj0 = 0 ;
19504 PyObject * obj1 = 0 ;
19505 char * kwnames[] = {
19506 (char *) "self",(char *) "pos", NULL
19507 };
19508
19509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19511 if (!SWIG_IsOK(res1)) {
19512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19513 }
19514 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19515 ecode2 = SWIG_AsVal_int(obj1, &val2);
19516 if (!SWIG_IsOK(ecode2)) {
19517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19518 }
19519 arg2 = static_cast< int >(val2);
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 (arg1)->SetPosition(arg2);
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 resultobj = SWIG_Py_Void();
19527 return resultobj;
19528 fail:
19529 return NULL;
19530 }
19531
19532
19533 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19534 PyObject *obj;
19535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19536 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19537 return SWIG_Py_Void();
19538 }
19539
19540 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19541 return SWIG_Python_InitShadowInstance(args);
19542 }
19543
19544 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19545 PyObject *resultobj = 0;
19546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19547 int arg2 = (int) 0 ;
19548 int arg3 = (int) 0 ;
19549 wxScrollWinEvent *result = 0 ;
19550 int val1 ;
19551 int ecode1 = 0 ;
19552 int val2 ;
19553 int ecode2 = 0 ;
19554 int val3 ;
19555 int ecode3 = 0 ;
19556 PyObject * obj0 = 0 ;
19557 PyObject * obj1 = 0 ;
19558 PyObject * obj2 = 0 ;
19559 char * kwnames[] = {
19560 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19561 };
19562
19563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19564 if (obj0) {
19565 ecode1 = SWIG_AsVal_int(obj0, &val1);
19566 if (!SWIG_IsOK(ecode1)) {
19567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19568 }
19569 arg1 = static_cast< wxEventType >(val1);
19570 }
19571 if (obj1) {
19572 ecode2 = SWIG_AsVal_int(obj1, &val2);
19573 if (!SWIG_IsOK(ecode2)) {
19574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19575 }
19576 arg2 = static_cast< int >(val2);
19577 }
19578 if (obj2) {
19579 ecode3 = SWIG_AsVal_int(obj2, &val3);
19580 if (!SWIG_IsOK(ecode3)) {
19581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19582 }
19583 arg3 = static_cast< int >(val3);
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19588 wxPyEndAllowThreads(__tstate);
19589 if (PyErr_Occurred()) SWIG_fail;
19590 }
19591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19592 return resultobj;
19593 fail:
19594 return NULL;
19595 }
19596
19597
19598 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19599 PyObject *resultobj = 0;
19600 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19601 int result;
19602 void *argp1 = 0 ;
19603 int res1 = 0 ;
19604 PyObject *swig_obj[1] ;
19605
19606 if (!args) SWIG_fail;
19607 swig_obj[0] = args;
19608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19609 if (!SWIG_IsOK(res1)) {
19610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19611 }
19612 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_From_int(static_cast< int >(result));
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19627 PyObject *resultobj = 0;
19628 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19629 int result;
19630 void *argp1 = 0 ;
19631 int res1 = 0 ;
19632 PyObject *swig_obj[1] ;
19633
19634 if (!args) SWIG_fail;
19635 swig_obj[0] = args;
19636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19637 if (!SWIG_IsOK(res1)) {
19638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19639 }
19640 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_From_int(static_cast< int >(result));
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19655 PyObject *resultobj = 0;
19656 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19657 int arg2 ;
19658 void *argp1 = 0 ;
19659 int res1 = 0 ;
19660 int val2 ;
19661 int ecode2 = 0 ;
19662 PyObject * obj0 = 0 ;
19663 PyObject * obj1 = 0 ;
19664 char * kwnames[] = {
19665 (char *) "self",(char *) "orient", NULL
19666 };
19667
19668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19670 if (!SWIG_IsOK(res1)) {
19671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19672 }
19673 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19674 ecode2 = SWIG_AsVal_int(obj1, &val2);
19675 if (!SWIG_IsOK(ecode2)) {
19676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19677 }
19678 arg2 = static_cast< int >(val2);
19679 {
19680 PyThreadState* __tstate = wxPyBeginAllowThreads();
19681 (arg1)->SetOrientation(arg2);
19682 wxPyEndAllowThreads(__tstate);
19683 if (PyErr_Occurred()) SWIG_fail;
19684 }
19685 resultobj = SWIG_Py_Void();
19686 return resultobj;
19687 fail:
19688 return NULL;
19689 }
19690
19691
19692 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19693 PyObject *resultobj = 0;
19694 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19695 int arg2 ;
19696 void *argp1 = 0 ;
19697 int res1 = 0 ;
19698 int val2 ;
19699 int ecode2 = 0 ;
19700 PyObject * obj0 = 0 ;
19701 PyObject * obj1 = 0 ;
19702 char * kwnames[] = {
19703 (char *) "self",(char *) "pos", NULL
19704 };
19705
19706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19708 if (!SWIG_IsOK(res1)) {
19709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19710 }
19711 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19712 ecode2 = SWIG_AsVal_int(obj1, &val2);
19713 if (!SWIG_IsOK(ecode2)) {
19714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19715 }
19716 arg2 = static_cast< int >(val2);
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 (arg1)->SetPosition(arg2);
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 resultobj = SWIG_Py_Void();
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19731 PyObject *obj;
19732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19733 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19734 return SWIG_Py_Void();
19735 }
19736
19737 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19738 return SWIG_Python_InitShadowInstance(args);
19739 }
19740
19741 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj = 0;
19743 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19744 wxMouseEvent *result = 0 ;
19745 int val1 ;
19746 int ecode1 = 0 ;
19747 PyObject * obj0 = 0 ;
19748 char * kwnames[] = {
19749 (char *) "mouseType", NULL
19750 };
19751
19752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19753 if (obj0) {
19754 ecode1 = SWIG_AsVal_int(obj0, &val1);
19755 if (!SWIG_IsOK(ecode1)) {
19756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19757 }
19758 arg1 = static_cast< wxEventType >(val1);
19759 }
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19763 wxPyEndAllowThreads(__tstate);
19764 if (PyErr_Occurred()) SWIG_fail;
19765 }
19766 {
19767 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19768 }
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19776 PyObject *resultobj = 0;
19777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19778 bool result;
19779 void *argp1 = 0 ;
19780 int res1 = 0 ;
19781 PyObject *swig_obj[1] ;
19782
19783 if (!args) SWIG_fail;
19784 swig_obj[0] = args;
19785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19786 if (!SWIG_IsOK(res1)) {
19787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19788 }
19789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19790 {
19791 PyThreadState* __tstate = wxPyBeginAllowThreads();
19792 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 {
19797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19798 }
19799 return resultobj;
19800 fail:
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = 0;
19807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19808 int arg2 = (int) wxMOUSE_BTN_ANY ;
19809 bool result;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 int val2 ;
19813 int ecode2 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char * kwnames[] = {
19817 (char *) "self",(char *) "but", NULL
19818 };
19819
19820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19822 if (!SWIG_IsOK(res1)) {
19823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19824 }
19825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19826 if (obj1) {
19827 ecode2 = SWIG_AsVal_int(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19830 }
19831 arg2 = static_cast< int >(val2);
19832 }
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 {
19840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19841 }
19842 return resultobj;
19843 fail:
19844 return NULL;
19845 }
19846
19847
19848 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19849 PyObject *resultobj = 0;
19850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19851 int arg2 = (int) wxMOUSE_BTN_ANY ;
19852 bool result;
19853 void *argp1 = 0 ;
19854 int res1 = 0 ;
19855 int val2 ;
19856 int ecode2 = 0 ;
19857 PyObject * obj0 = 0 ;
19858 PyObject * obj1 = 0 ;
19859 char * kwnames[] = {
19860 (char *) "self",(char *) "but", NULL
19861 };
19862
19863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19867 }
19868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19869 if (obj1) {
19870 ecode2 = SWIG_AsVal_int(obj1, &val2);
19871 if (!SWIG_IsOK(ecode2)) {
19872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19873 }
19874 arg2 = static_cast< int >(val2);
19875 }
19876 {
19877 PyThreadState* __tstate = wxPyBeginAllowThreads();
19878 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 {
19883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19884 }
19885 return resultobj;
19886 fail:
19887 return NULL;
19888 }
19889
19890
19891 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19892 PyObject *resultobj = 0;
19893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19894 int arg2 = (int) wxMOUSE_BTN_ANY ;
19895 bool result;
19896 void *argp1 = 0 ;
19897 int res1 = 0 ;
19898 int val2 ;
19899 int ecode2 = 0 ;
19900 PyObject * obj0 = 0 ;
19901 PyObject * obj1 = 0 ;
19902 char * kwnames[] = {
19903 (char *) "self",(char *) "but", NULL
19904 };
19905
19906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19908 if (!SWIG_IsOK(res1)) {
19909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19910 }
19911 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19912 if (obj1) {
19913 ecode2 = SWIG_AsVal_int(obj1, &val2);
19914 if (!SWIG_IsOK(ecode2)) {
19915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19916 }
19917 arg2 = static_cast< int >(val2);
19918 }
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19927 }
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = 0;
19936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19937 int arg2 ;
19938 bool result;
19939 void *argp1 = 0 ;
19940 int res1 = 0 ;
19941 int val2 ;
19942 int ecode2 = 0 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char * kwnames[] = {
19946 (char *) "self",(char *) "button", NULL
19947 };
19948
19949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19951 if (!SWIG_IsOK(res1)) {
19952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19953 }
19954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19955 ecode2 = SWIG_AsVal_int(obj1, &val2);
19956 if (!SWIG_IsOK(ecode2)) {
19957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19958 }
19959 arg2 = static_cast< int >(val2);
19960 {
19961 PyThreadState* __tstate = wxPyBeginAllowThreads();
19962 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19963 wxPyEndAllowThreads(__tstate);
19964 if (PyErr_Occurred()) SWIG_fail;
19965 }
19966 {
19967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19968 }
19969 return resultobj;
19970 fail:
19971 return NULL;
19972 }
19973
19974
19975 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj = 0;
19977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19978 int arg2 ;
19979 bool result;
19980 void *argp1 = 0 ;
19981 int res1 = 0 ;
19982 int val2 ;
19983 int ecode2 = 0 ;
19984 PyObject * obj0 = 0 ;
19985 PyObject * obj1 = 0 ;
19986 char * kwnames[] = {
19987 (char *) "self",(char *) "but", NULL
19988 };
19989
19990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19992 if (!SWIG_IsOK(res1)) {
19993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19994 }
19995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19996 ecode2 = SWIG_AsVal_int(obj1, &val2);
19997 if (!SWIG_IsOK(ecode2)) {
19998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19999 }
20000 arg2 = static_cast< int >(val2);
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20004 wxPyEndAllowThreads(__tstate);
20005 if (PyErr_Occurred()) SWIG_fail;
20006 }
20007 {
20008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20009 }
20010 return resultobj;
20011 fail:
20012 return NULL;
20013 }
20014
20015
20016 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20017 PyObject *resultobj = 0;
20018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20019 int result;
20020 void *argp1 = 0 ;
20021 int res1 = 0 ;
20022 PyObject *swig_obj[1] ;
20023
20024 if (!args) SWIG_fail;
20025 swig_obj[0] = args;
20026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20027 if (!SWIG_IsOK(res1)) {
20028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20029 }
20030 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20031 {
20032 PyThreadState* __tstate = wxPyBeginAllowThreads();
20033 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20034 wxPyEndAllowThreads(__tstate);
20035 if (PyErr_Occurred()) SWIG_fail;
20036 }
20037 resultobj = SWIG_From_int(static_cast< int >(result));
20038 return resultobj;
20039 fail:
20040 return NULL;
20041 }
20042
20043
20044 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20045 PyObject *resultobj = 0;
20046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20047 bool result;
20048 void *argp1 = 0 ;
20049 int res1 = 0 ;
20050 PyObject *swig_obj[1] ;
20051
20052 if (!args) SWIG_fail;
20053 swig_obj[0] = args;
20054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20057 }
20058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 {
20066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20067 }
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20075 PyObject *resultobj = 0;
20076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20077 bool result;
20078 void *argp1 = 0 ;
20079 int res1 = 0 ;
20080 PyObject *swig_obj[1] ;
20081
20082 if (!args) SWIG_fail;
20083 swig_obj[0] = args;
20084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20085 if (!SWIG_IsOK(res1)) {
20086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20087 }
20088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 {
20096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20097 }
20098 return resultobj;
20099 fail:
20100 return NULL;
20101 }
20102
20103
20104 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20105 PyObject *resultobj = 0;
20106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20107 bool result;
20108 void *argp1 = 0 ;
20109 int res1 = 0 ;
20110 PyObject *swig_obj[1] ;
20111
20112 if (!args) SWIG_fail;
20113 swig_obj[0] = args;
20114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20115 if (!SWIG_IsOK(res1)) {
20116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20117 }
20118 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20122 wxPyEndAllowThreads(__tstate);
20123 if (PyErr_Occurred()) SWIG_fail;
20124 }
20125 {
20126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20127 }
20128 return resultobj;
20129 fail:
20130 return NULL;
20131 }
20132
20133
20134 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20135 PyObject *resultobj = 0;
20136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20137 bool result;
20138 void *argp1 = 0 ;
20139 int res1 = 0 ;
20140 PyObject *swig_obj[1] ;
20141
20142 if (!args) SWIG_fail;
20143 swig_obj[0] = args;
20144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20145 if (!SWIG_IsOK(res1)) {
20146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20147 }
20148 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20149 {
20150 PyThreadState* __tstate = wxPyBeginAllowThreads();
20151 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20152 wxPyEndAllowThreads(__tstate);
20153 if (PyErr_Occurred()) SWIG_fail;
20154 }
20155 {
20156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20157 }
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20165 PyObject *resultobj = 0;
20166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20167 bool result;
20168 void *argp1 = 0 ;
20169 int res1 = 0 ;
20170 PyObject *swig_obj[1] ;
20171
20172 if (!args) SWIG_fail;
20173 swig_obj[0] = args;
20174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20175 if (!SWIG_IsOK(res1)) {
20176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20177 }
20178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20179 {
20180 PyThreadState* __tstate = wxPyBeginAllowThreads();
20181 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 {
20186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20195 PyObject *resultobj = 0;
20196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20197 bool result;
20198 void *argp1 = 0 ;
20199 int res1 = 0 ;
20200 PyObject *swig_obj[1] ;
20201
20202 if (!args) SWIG_fail;
20203 swig_obj[0] = args;
20204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20205 if (!SWIG_IsOK(res1)) {
20206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20207 }
20208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20212 wxPyEndAllowThreads(__tstate);
20213 if (PyErr_Occurred()) SWIG_fail;
20214 }
20215 {
20216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20217 }
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20225 PyObject *resultobj = 0;
20226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20227 bool result;
20228 void *argp1 = 0 ;
20229 int res1 = 0 ;
20230 PyObject *swig_obj[1] ;
20231
20232 if (!args) SWIG_fail;
20233 swig_obj[0] = args;
20234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20235 if (!SWIG_IsOK(res1)) {
20236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20237 }
20238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20239 {
20240 PyThreadState* __tstate = wxPyBeginAllowThreads();
20241 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 {
20246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20247 }
20248 return resultobj;
20249 fail:
20250 return NULL;
20251 }
20252
20253
20254 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 PyObject *resultobj = 0;
20256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20257 bool result;
20258 void *argp1 = 0 ;
20259 int res1 = 0 ;
20260 PyObject *swig_obj[1] ;
20261
20262 if (!args) SWIG_fail;
20263 swig_obj[0] = args;
20264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20265 if (!SWIG_IsOK(res1)) {
20266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20267 }
20268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20269 {
20270 PyThreadState* __tstate = wxPyBeginAllowThreads();
20271 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 {
20276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20277 }
20278 return resultobj;
20279 fail:
20280 return NULL;
20281 }
20282
20283
20284 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20285 PyObject *resultobj = 0;
20286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20287 bool result;
20288 void *argp1 = 0 ;
20289 int res1 = 0 ;
20290 PyObject *swig_obj[1] ;
20291
20292 if (!args) SWIG_fail;
20293 swig_obj[0] = args;
20294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20295 if (!SWIG_IsOK(res1)) {
20296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20297 }
20298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 {
20306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20307 }
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20315 PyObject *resultobj = 0;
20316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20317 bool result;
20318 void *argp1 = 0 ;
20319 int res1 = 0 ;
20320 PyObject *swig_obj[1] ;
20321
20322 if (!args) SWIG_fail;
20323 swig_obj[0] = args;
20324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20325 if (!SWIG_IsOK(res1)) {
20326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20327 }
20328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20332 wxPyEndAllowThreads(__tstate);
20333 if (PyErr_Occurred()) SWIG_fail;
20334 }
20335 {
20336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20337 }
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20347 bool result;
20348 void *argp1 = 0 ;
20349 int res1 = 0 ;
20350 PyObject *swig_obj[1] ;
20351
20352 if (!args) SWIG_fail;
20353 swig_obj[0] = args;
20354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20355 if (!SWIG_IsOK(res1)) {
20356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20357 }
20358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 {
20366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20367 }
20368 return resultobj;
20369 fail:
20370 return NULL;
20371 }
20372
20373
20374 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20377 bool result;
20378 void *argp1 = 0 ;
20379 int res1 = 0 ;
20380 PyObject *swig_obj[1] ;
20381
20382 if (!args) SWIG_fail;
20383 swig_obj[0] = args;
20384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20385 if (!SWIG_IsOK(res1)) {
20386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20387 }
20388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20389 {
20390 PyThreadState* __tstate = wxPyBeginAllowThreads();
20391 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20392 wxPyEndAllowThreads(__tstate);
20393 if (PyErr_Occurred()) SWIG_fail;
20394 }
20395 {
20396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20397 }
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20405 PyObject *resultobj = 0;
20406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20407 bool result;
20408 void *argp1 = 0 ;
20409 int res1 = 0 ;
20410 PyObject *swig_obj[1] ;
20411
20412 if (!args) SWIG_fail;
20413 swig_obj[0] = args;
20414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20415 if (!SWIG_IsOK(res1)) {
20416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20417 }
20418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 {
20426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20427 }
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435 PyObject *resultobj = 0;
20436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20437 bool result;
20438 void *argp1 = 0 ;
20439 int res1 = 0 ;
20440 PyObject *swig_obj[1] ;
20441
20442 if (!args) SWIG_fail;
20443 swig_obj[0] = args;
20444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20445 if (!SWIG_IsOK(res1)) {
20446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20447 }
20448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 {
20456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20457 }
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20467 bool result;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 PyObject *swig_obj[1] ;
20471
20472 if (!args) SWIG_fail;
20473 swig_obj[0] = args;
20474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20475 if (!SWIG_IsOK(res1)) {
20476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20477 }
20478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 result = (bool)(arg1)->LeftIsDown();
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 {
20486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20487 }
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20495 PyObject *resultobj = 0;
20496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20497 bool result;
20498 void *argp1 = 0 ;
20499 int res1 = 0 ;
20500 PyObject *swig_obj[1] ;
20501
20502 if (!args) SWIG_fail;
20503 swig_obj[0] = args;
20504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20505 if (!SWIG_IsOK(res1)) {
20506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20507 }
20508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (bool)(arg1)->MiddleIsDown();
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 {
20516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20517 }
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20527 bool result;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20537 }
20538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (bool)(arg1)->RightIsDown();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20547 }
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20555 PyObject *resultobj = 0;
20556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20557 bool result;
20558 void *argp1 = 0 ;
20559 int res1 = 0 ;
20560 PyObject *swig_obj[1] ;
20561
20562 if (!args) SWIG_fail;
20563 swig_obj[0] = args;
20564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20567 }
20568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 {
20576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20577 }
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20585 PyObject *resultobj = 0;
20586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20587 bool result;
20588 void *argp1 = 0 ;
20589 int res1 = 0 ;
20590 PyObject *swig_obj[1] ;
20591
20592 if (!args) SWIG_fail;
20593 swig_obj[0] = args;
20594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20595 if (!SWIG_IsOK(res1)) {
20596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20597 }
20598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20599 {
20600 PyThreadState* __tstate = wxPyBeginAllowThreads();
20601 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20602 wxPyEndAllowThreads(__tstate);
20603 if (PyErr_Occurred()) SWIG_fail;
20604 }
20605 {
20606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20607 }
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20615 PyObject *resultobj = 0;
20616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20617 bool result;
20618 void *argp1 = 0 ;
20619 int res1 = 0 ;
20620 PyObject *swig_obj[1] ;
20621
20622 if (!args) SWIG_fail;
20623 swig_obj[0] = args;
20624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20627 }
20628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645 PyObject *resultobj = 0;
20646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20647 bool result;
20648 void *argp1 = 0 ;
20649 int res1 = 0 ;
20650 PyObject *swig_obj[1] ;
20651
20652 if (!args) SWIG_fail;
20653 swig_obj[0] = args;
20654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20655 if (!SWIG_IsOK(res1)) {
20656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20657 }
20658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20675 PyObject *resultobj = 0;
20676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20677 wxPoint result;
20678 void *argp1 = 0 ;
20679 int res1 = 0 ;
20680 PyObject *swig_obj[1] ;
20681
20682 if (!args) SWIG_fail;
20683 swig_obj[0] = args;
20684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20687 }
20688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20689 {
20690 PyThreadState* __tstate = wxPyBeginAllowThreads();
20691 result = (arg1)->GetPosition();
20692 wxPyEndAllowThreads(__tstate);
20693 if (PyErr_Occurred()) SWIG_fail;
20694 }
20695 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20703 PyObject *resultobj = 0;
20704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20705 long *arg2 = (long *) 0 ;
20706 long *arg3 = (long *) 0 ;
20707 void *argp1 = 0 ;
20708 int res1 = 0 ;
20709 long temp2 ;
20710 int res2 = SWIG_TMPOBJ ;
20711 long temp3 ;
20712 int res3 = SWIG_TMPOBJ ;
20713 PyObject *swig_obj[1] ;
20714
20715 arg2 = &temp2;
20716 arg3 = &temp3;
20717 if (!args) SWIG_fail;
20718 swig_obj[0] = args;
20719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20722 }
20723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20724 {
20725 PyThreadState* __tstate = wxPyBeginAllowThreads();
20726 (arg1)->GetPosition(arg2,arg3);
20727 wxPyEndAllowThreads(__tstate);
20728 if (PyErr_Occurred()) SWIG_fail;
20729 }
20730 resultobj = SWIG_Py_Void();
20731 if (SWIG_IsTmpObj(res2)) {
20732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20733 } else {
20734 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20736 }
20737 if (SWIG_IsTmpObj(res3)) {
20738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20739 } else {
20740 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20742 }
20743 return resultobj;
20744 fail:
20745 return NULL;
20746 }
20747
20748
20749 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20750 PyObject *resultobj = 0;
20751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20752 wxDC *arg2 = 0 ;
20753 wxPoint result;
20754 void *argp1 = 0 ;
20755 int res1 = 0 ;
20756 void *argp2 = 0 ;
20757 int res2 = 0 ;
20758 PyObject * obj0 = 0 ;
20759 PyObject * obj1 = 0 ;
20760 char * kwnames[] = {
20761 (char *) "self",(char *) "dc", NULL
20762 };
20763
20764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20766 if (!SWIG_IsOK(res1)) {
20767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20768 }
20769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20771 if (!SWIG_IsOK(res2)) {
20772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20773 }
20774 if (!argp2) {
20775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20776 }
20777 arg2 = reinterpret_cast< wxDC * >(argp2);
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20781 wxPyEndAllowThreads(__tstate);
20782 if (PyErr_Occurred()) SWIG_fail;
20783 }
20784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 PyObject *resultobj = 0;
20793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20794 int result;
20795 void *argp1 = 0 ;
20796 int res1 = 0 ;
20797 PyObject *swig_obj[1] ;
20798
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (int)((wxMouseEvent const *)arg1)->GetX();
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 resultobj = SWIG_From_int(static_cast< int >(result));
20813 return resultobj;
20814 fail:
20815 return NULL;
20816 }
20817
20818
20819 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20820 PyObject *resultobj = 0;
20821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20822 int result;
20823 void *argp1 = 0 ;
20824 int res1 = 0 ;
20825 PyObject *swig_obj[1] ;
20826
20827 if (!args) SWIG_fail;
20828 swig_obj[0] = args;
20829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20830 if (!SWIG_IsOK(res1)) {
20831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20832 }
20833 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20834 {
20835 PyThreadState* __tstate = wxPyBeginAllowThreads();
20836 result = (int)((wxMouseEvent const *)arg1)->GetY();
20837 wxPyEndAllowThreads(__tstate);
20838 if (PyErr_Occurred()) SWIG_fail;
20839 }
20840 resultobj = SWIG_From_int(static_cast< int >(result));
20841 return resultobj;
20842 fail:
20843 return NULL;
20844 }
20845
20846
20847 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20848 PyObject *resultobj = 0;
20849 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20850 int result;
20851 void *argp1 = 0 ;
20852 int res1 = 0 ;
20853 PyObject *swig_obj[1] ;
20854
20855 if (!args) SWIG_fail;
20856 swig_obj[0] = args;
20857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20858 if (!SWIG_IsOK(res1)) {
20859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20860 }
20861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20865 wxPyEndAllowThreads(__tstate);
20866 if (PyErr_Occurred()) SWIG_fail;
20867 }
20868 resultobj = SWIG_From_int(static_cast< int >(result));
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20876 PyObject *resultobj = 0;
20877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20878 int result;
20879 void *argp1 = 0 ;
20880 int res1 = 0 ;
20881 PyObject *swig_obj[1] ;
20882
20883 if (!args) SWIG_fail;
20884 swig_obj[0] = args;
20885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20886 if (!SWIG_IsOK(res1)) {
20887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20888 }
20889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 resultobj = SWIG_From_int(static_cast< int >(result));
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20904 PyObject *resultobj = 0;
20905 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20906 int result;
20907 void *argp1 = 0 ;
20908 int res1 = 0 ;
20909 PyObject *swig_obj[1] ;
20910
20911 if (!args) SWIG_fail;
20912 swig_obj[0] = args;
20913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20914 if (!SWIG_IsOK(res1)) {
20915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20916 }
20917 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20918 {
20919 PyThreadState* __tstate = wxPyBeginAllowThreads();
20920 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 resultobj = SWIG_From_int(static_cast< int >(result));
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20932 PyObject *resultobj = 0;
20933 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20934 bool result;
20935 void *argp1 = 0 ;
20936 int res1 = 0 ;
20937 PyObject *swig_obj[1] ;
20938
20939 if (!args) SWIG_fail;
20940 swig_obj[0] = args;
20941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20942 if (!SWIG_IsOK(res1)) {
20943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20944 }
20945 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 {
20953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20954 }
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962 PyObject *resultobj = 0;
20963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20964 int arg2 ;
20965 void *argp1 = 0 ;
20966 int res1 = 0 ;
20967 int val2 ;
20968 int ecode2 = 0 ;
20969 PyObject *swig_obj[2] ;
20970
20971 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20975 }
20976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20977 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20978 if (!SWIG_IsOK(ecode2)) {
20979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20980 }
20981 arg2 = static_cast< int >(val2);
20982 if (arg1) (arg1)->m_x = arg2;
20983
20984 resultobj = SWIG_Py_Void();
20985 return resultobj;
20986 fail:
20987 return NULL;
20988 }
20989
20990
20991 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20992 PyObject *resultobj = 0;
20993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20994 int result;
20995 void *argp1 = 0 ;
20996 int res1 = 0 ;
20997 PyObject *swig_obj[1] ;
20998
20999 if (!args) SWIG_fail;
21000 swig_obj[0] = args;
21001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21004 }
21005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21006 result = (int) ((arg1)->m_x);
21007 resultobj = SWIG_From_int(static_cast< int >(result));
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 int arg2 ;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 int val2 ;
21021 int ecode2 = 0 ;
21022 PyObject *swig_obj[2] ;
21023
21024 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21028 }
21029 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21030 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21031 if (!SWIG_IsOK(ecode2)) {
21032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21033 }
21034 arg2 = static_cast< int >(val2);
21035 if (arg1) (arg1)->m_y = arg2;
21036
21037 resultobj = SWIG_Py_Void();
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045 PyObject *resultobj = 0;
21046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21047 int result;
21048 void *argp1 = 0 ;
21049 int res1 = 0 ;
21050 PyObject *swig_obj[1] ;
21051
21052 if (!args) SWIG_fail;
21053 swig_obj[0] = args;
21054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21057 }
21058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21059 result = (int) ((arg1)->m_y);
21060 resultobj = SWIG_From_int(static_cast< int >(result));
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21068 PyObject *resultobj = 0;
21069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21070 bool arg2 ;
21071 void *argp1 = 0 ;
21072 int res1 = 0 ;
21073 bool val2 ;
21074 int ecode2 = 0 ;
21075 PyObject *swig_obj[2] ;
21076
21077 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21079 if (!SWIG_IsOK(res1)) {
21080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21081 }
21082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21083 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21084 if (!SWIG_IsOK(ecode2)) {
21085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21086 }
21087 arg2 = static_cast< bool >(val2);
21088 if (arg1) (arg1)->m_leftDown = arg2;
21089
21090 resultobj = SWIG_Py_Void();
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 PyObject *resultobj = 0;
21099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21100 bool result;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 PyObject *swig_obj[1] ;
21104
21105 if (!args) SWIG_fail;
21106 swig_obj[0] = args;
21107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21108 if (!SWIG_IsOK(res1)) {
21109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21110 }
21111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21112 result = (bool) ((arg1)->m_leftDown);
21113 {
21114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21115 }
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 bool arg2 ;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 bool val2 ;
21129 int ecode2 = 0 ;
21130 PyObject *swig_obj[2] ;
21131
21132 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21134 if (!SWIG_IsOK(res1)) {
21135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21136 }
21137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21138 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21139 if (!SWIG_IsOK(ecode2)) {
21140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21141 }
21142 arg2 = static_cast< bool >(val2);
21143 if (arg1) (arg1)->m_middleDown = arg2;
21144
21145 resultobj = SWIG_Py_Void();
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21155 bool result;
21156 void *argp1 = 0 ;
21157 int res1 = 0 ;
21158 PyObject *swig_obj[1] ;
21159
21160 if (!args) SWIG_fail;
21161 swig_obj[0] = args;
21162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21165 }
21166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21167 result = (bool) ((arg1)->m_middleDown);
21168 {
21169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21170 }
21171 return resultobj;
21172 fail:
21173 return NULL;
21174 }
21175
21176
21177 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21178 PyObject *resultobj = 0;
21179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21180 bool arg2 ;
21181 void *argp1 = 0 ;
21182 int res1 = 0 ;
21183 bool val2 ;
21184 int ecode2 = 0 ;
21185 PyObject *swig_obj[2] ;
21186
21187 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21191 }
21192 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21193 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21194 if (!SWIG_IsOK(ecode2)) {
21195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21196 }
21197 arg2 = static_cast< bool >(val2);
21198 if (arg1) (arg1)->m_rightDown = arg2;
21199
21200 resultobj = SWIG_Py_Void();
21201 return resultobj;
21202 fail:
21203 return NULL;
21204 }
21205
21206
21207 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21208 PyObject *resultobj = 0;
21209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21210 bool result;
21211 void *argp1 = 0 ;
21212 int res1 = 0 ;
21213 PyObject *swig_obj[1] ;
21214
21215 if (!args) SWIG_fail;
21216 swig_obj[0] = args;
21217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21218 if (!SWIG_IsOK(res1)) {
21219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21220 }
21221 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21222 result = (bool) ((arg1)->m_rightDown);
21223 {
21224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21225 }
21226 return resultobj;
21227 fail:
21228 return NULL;
21229 }
21230
21231
21232 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21233 PyObject *resultobj = 0;
21234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21235 bool arg2 ;
21236 void *argp1 = 0 ;
21237 int res1 = 0 ;
21238 bool val2 ;
21239 int ecode2 = 0 ;
21240 PyObject *swig_obj[2] ;
21241
21242 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21244 if (!SWIG_IsOK(res1)) {
21245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21246 }
21247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21248 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21249 if (!SWIG_IsOK(ecode2)) {
21250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21251 }
21252 arg2 = static_cast< bool >(val2);
21253 if (arg1) (arg1)->m_controlDown = arg2;
21254
21255 resultobj = SWIG_Py_Void();
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21263 PyObject *resultobj = 0;
21264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21265 bool result;
21266 void *argp1 = 0 ;
21267 int res1 = 0 ;
21268 PyObject *swig_obj[1] ;
21269
21270 if (!args) SWIG_fail;
21271 swig_obj[0] = args;
21272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21273 if (!SWIG_IsOK(res1)) {
21274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21275 }
21276 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21277 result = (bool) ((arg1)->m_controlDown);
21278 {
21279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21280 }
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21288 PyObject *resultobj = 0;
21289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21290 bool arg2 ;
21291 void *argp1 = 0 ;
21292 int res1 = 0 ;
21293 bool val2 ;
21294 int ecode2 = 0 ;
21295 PyObject *swig_obj[2] ;
21296
21297 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21299 if (!SWIG_IsOK(res1)) {
21300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21301 }
21302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21303 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21304 if (!SWIG_IsOK(ecode2)) {
21305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21306 }
21307 arg2 = static_cast< bool >(val2);
21308 if (arg1) (arg1)->m_shiftDown = arg2;
21309
21310 resultobj = SWIG_Py_Void();
21311 return resultobj;
21312 fail:
21313 return NULL;
21314 }
21315
21316
21317 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21318 PyObject *resultobj = 0;
21319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21320 bool result;
21321 void *argp1 = 0 ;
21322 int res1 = 0 ;
21323 PyObject *swig_obj[1] ;
21324
21325 if (!args) SWIG_fail;
21326 swig_obj[0] = args;
21327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21328 if (!SWIG_IsOK(res1)) {
21329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21330 }
21331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21332 result = (bool) ((arg1)->m_shiftDown);
21333 {
21334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21335 }
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21343 PyObject *resultobj = 0;
21344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21345 bool arg2 ;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 bool val2 ;
21349 int ecode2 = 0 ;
21350 PyObject *swig_obj[2] ;
21351
21352 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21358 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21359 if (!SWIG_IsOK(ecode2)) {
21360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21361 }
21362 arg2 = static_cast< bool >(val2);
21363 if (arg1) (arg1)->m_altDown = arg2;
21364
21365 resultobj = SWIG_Py_Void();
21366 return resultobj;
21367 fail:
21368 return NULL;
21369 }
21370
21371
21372 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21373 PyObject *resultobj = 0;
21374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21375 bool result;
21376 void *argp1 = 0 ;
21377 int res1 = 0 ;
21378 PyObject *swig_obj[1] ;
21379
21380 if (!args) SWIG_fail;
21381 swig_obj[0] = args;
21382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21383 if (!SWIG_IsOK(res1)) {
21384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21385 }
21386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21387 result = (bool) ((arg1)->m_altDown);
21388 {
21389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21398 PyObject *resultobj = 0;
21399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21400 bool arg2 ;
21401 void *argp1 = 0 ;
21402 int res1 = 0 ;
21403 bool val2 ;
21404 int ecode2 = 0 ;
21405 PyObject *swig_obj[2] ;
21406
21407 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21409 if (!SWIG_IsOK(res1)) {
21410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21411 }
21412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21413 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21414 if (!SWIG_IsOK(ecode2)) {
21415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21416 }
21417 arg2 = static_cast< bool >(val2);
21418 if (arg1) (arg1)->m_metaDown = arg2;
21419
21420 resultobj = SWIG_Py_Void();
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21428 PyObject *resultobj = 0;
21429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21430 bool result;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 PyObject *swig_obj[1] ;
21434
21435 if (!args) SWIG_fail;
21436 swig_obj[0] = args;
21437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21438 if (!SWIG_IsOK(res1)) {
21439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21440 }
21441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21442 result = (bool) ((arg1)->m_metaDown);
21443 {
21444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21445 }
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21453 PyObject *resultobj = 0;
21454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21455 int arg2 ;
21456 void *argp1 = 0 ;
21457 int res1 = 0 ;
21458 int val2 ;
21459 int ecode2 = 0 ;
21460 PyObject *swig_obj[2] ;
21461
21462 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21464 if (!SWIG_IsOK(res1)) {
21465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21466 }
21467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21468 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21469 if (!SWIG_IsOK(ecode2)) {
21470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21471 }
21472 arg2 = static_cast< int >(val2);
21473 if (arg1) (arg1)->m_wheelRotation = arg2;
21474
21475 resultobj = SWIG_Py_Void();
21476 return resultobj;
21477 fail:
21478 return NULL;
21479 }
21480
21481
21482 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21483 PyObject *resultobj = 0;
21484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21485 int result;
21486 void *argp1 = 0 ;
21487 int res1 = 0 ;
21488 PyObject *swig_obj[1] ;
21489
21490 if (!args) SWIG_fail;
21491 swig_obj[0] = args;
21492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21495 }
21496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21497 result = (int) ((arg1)->m_wheelRotation);
21498 resultobj = SWIG_From_int(static_cast< int >(result));
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 PyObject *resultobj = 0;
21507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21508 int arg2 ;
21509 void *argp1 = 0 ;
21510 int res1 = 0 ;
21511 int val2 ;
21512 int ecode2 = 0 ;
21513 PyObject *swig_obj[2] ;
21514
21515 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21517 if (!SWIG_IsOK(res1)) {
21518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21519 }
21520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21521 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21522 if (!SWIG_IsOK(ecode2)) {
21523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21524 }
21525 arg2 = static_cast< int >(val2);
21526 if (arg1) (arg1)->m_wheelDelta = arg2;
21527
21528 resultobj = SWIG_Py_Void();
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21536 PyObject *resultobj = 0;
21537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21538 int result;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 PyObject *swig_obj[1] ;
21542
21543 if (!args) SWIG_fail;
21544 swig_obj[0] = args;
21545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21546 if (!SWIG_IsOK(res1)) {
21547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21548 }
21549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21550 result = (int) ((arg1)->m_wheelDelta);
21551 resultobj = SWIG_From_int(static_cast< int >(result));
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 int arg2 ;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 int val2 ;
21565 int ecode2 = 0 ;
21566 PyObject *swig_obj[2] ;
21567
21568 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21570 if (!SWIG_IsOK(res1)) {
21571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21572 }
21573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21574 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21575 if (!SWIG_IsOK(ecode2)) {
21576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21577 }
21578 arg2 = static_cast< int >(val2);
21579 if (arg1) (arg1)->m_linesPerAction = arg2;
21580
21581 resultobj = SWIG_Py_Void();
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 int result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 result = (int) ((arg1)->m_linesPerAction);
21604 resultobj = SWIG_From_int(static_cast< int >(result));
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *obj;
21613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21614 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21615 return SWIG_Py_Void();
21616 }
21617
21618 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 return SWIG_Python_InitShadowInstance(args);
21620 }
21621
21622 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj = 0;
21624 int arg1 = (int) 0 ;
21625 int arg2 = (int) 0 ;
21626 wxSetCursorEvent *result = 0 ;
21627 int val1 ;
21628 int ecode1 = 0 ;
21629 int val2 ;
21630 int ecode2 = 0 ;
21631 PyObject * obj0 = 0 ;
21632 PyObject * obj1 = 0 ;
21633 char * kwnames[] = {
21634 (char *) "x",(char *) "y", NULL
21635 };
21636
21637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21638 if (obj0) {
21639 ecode1 = SWIG_AsVal_int(obj0, &val1);
21640 if (!SWIG_IsOK(ecode1)) {
21641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21642 }
21643 arg1 = static_cast< int >(val1);
21644 }
21645 if (obj1) {
21646 ecode2 = SWIG_AsVal_int(obj1, &val2);
21647 if (!SWIG_IsOK(ecode2)) {
21648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21649 }
21650 arg2 = static_cast< int >(val2);
21651 }
21652 {
21653 PyThreadState* __tstate = wxPyBeginAllowThreads();
21654 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *resultobj = 0;
21667 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21668 int result;
21669 void *argp1 = 0 ;
21670 int res1 = 0 ;
21671 PyObject *swig_obj[1] ;
21672
21673 if (!args) SWIG_fail;
21674 swig_obj[0] = args;
21675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21678 }
21679 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 resultobj = SWIG_From_int(static_cast< int >(result));
21687 return resultobj;
21688 fail:
21689 return NULL;
21690 }
21691
21692
21693 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21694 PyObject *resultobj = 0;
21695 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21696 int result;
21697 void *argp1 = 0 ;
21698 int res1 = 0 ;
21699 PyObject *swig_obj[1] ;
21700
21701 if (!args) SWIG_fail;
21702 swig_obj[0] = args;
21703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21704 if (!SWIG_IsOK(res1)) {
21705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21706 }
21707 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21711 wxPyEndAllowThreads(__tstate);
21712 if (PyErr_Occurred()) SWIG_fail;
21713 }
21714 resultobj = SWIG_From_int(static_cast< int >(result));
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21722 PyObject *resultobj = 0;
21723 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21724 wxCursor *arg2 = 0 ;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 void *argp2 = 0 ;
21728 int res2 = 0 ;
21729 PyObject * obj0 = 0 ;
21730 PyObject * obj1 = 0 ;
21731 char * kwnames[] = {
21732 (char *) "self",(char *) "cursor", NULL
21733 };
21734
21735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21737 if (!SWIG_IsOK(res1)) {
21738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21739 }
21740 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21742 if (!SWIG_IsOK(res2)) {
21743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21744 }
21745 if (!argp2) {
21746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21747 }
21748 arg2 = reinterpret_cast< wxCursor * >(argp2);
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 (arg1)->SetCursor((wxCursor const &)*arg2);
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 resultobj = SWIG_Py_Void();
21756 return resultobj;
21757 fail:
21758 return NULL;
21759 }
21760
21761
21762 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21763 PyObject *resultobj = 0;
21764 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21765 wxCursor *result = 0 ;
21766 void *argp1 = 0 ;
21767 int res1 = 0 ;
21768 PyObject *swig_obj[1] ;
21769
21770 if (!args) SWIG_fail;
21771 swig_obj[0] = args;
21772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21773 if (!SWIG_IsOK(res1)) {
21774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21775 }
21776 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21777 {
21778 PyThreadState* __tstate = wxPyBeginAllowThreads();
21779 {
21780 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21781 result = (wxCursor *) &_result_ref;
21782 }
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 {
21787 wxCursor* resultptr = new wxCursor(*result);
21788 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21789 }
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *resultobj = 0;
21798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21799 bool result;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 PyObject *swig_obj[1] ;
21803
21804 if (!args) SWIG_fail;
21805 swig_obj[0] = args;
21806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21807 if (!SWIG_IsOK(res1)) {
21808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21809 }
21810 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 {
21818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21819 }
21820 return resultobj;
21821 fail:
21822 return NULL;
21823 }
21824
21825
21826 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21827 PyObject *obj;
21828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21829 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21830 return SWIG_Py_Void();
21831 }
21832
21833 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21834 return SWIG_Python_InitShadowInstance(args);
21835 }
21836
21837 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21838 PyObject *resultobj = 0;
21839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21840 wxKeyEvent *result = 0 ;
21841 int val1 ;
21842 int ecode1 = 0 ;
21843 PyObject * obj0 = 0 ;
21844 char * kwnames[] = {
21845 (char *) "eventType", NULL
21846 };
21847
21848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21849 if (obj0) {
21850 ecode1 = SWIG_AsVal_int(obj0, &val1);
21851 if (!SWIG_IsOK(ecode1)) {
21852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21853 }
21854 arg1 = static_cast< wxEventType >(val1);
21855 }
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21863 return resultobj;
21864 fail:
21865 return NULL;
21866 }
21867
21868
21869 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21870 PyObject *resultobj = 0;
21871 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21872 int result;
21873 void *argp1 = 0 ;
21874 int res1 = 0 ;
21875 PyObject *swig_obj[1] ;
21876
21877 if (!args) SWIG_fail;
21878 swig_obj[0] = args;
21879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21880 if (!SWIG_IsOK(res1)) {
21881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21882 }
21883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 resultobj = SWIG_From_int(static_cast< int >(result));
21891 return resultobj;
21892 fail:
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21898 PyObject *resultobj = 0;
21899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21900 bool result;
21901 void *argp1 = 0 ;
21902 int res1 = 0 ;
21903 PyObject *swig_obj[1] ;
21904
21905 if (!args) SWIG_fail;
21906 swig_obj[0] = args;
21907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21910 }
21911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *resultobj = 0;
21929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21930 bool result;
21931 void *argp1 = 0 ;
21932 int res1 = 0 ;
21933 PyObject *swig_obj[1] ;
21934
21935 if (!args) SWIG_fail;
21936 swig_obj[0] = args;
21937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21940 }
21941 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 {
21949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *resultobj = 0;
21959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21960 bool result;
21961 void *argp1 = 0 ;
21962 int res1 = 0 ;
21963 PyObject *swig_obj[1] ;
21964
21965 if (!args) SWIG_fail;
21966 swig_obj[0] = args;
21967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21970 }
21971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21980 }
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21988 PyObject *resultobj = 0;
21989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21990 bool result;
21991 void *argp1 = 0 ;
21992 int res1 = 0 ;
21993 PyObject *swig_obj[1] ;
21994
21995 if (!args) SWIG_fail;
21996 swig_obj[0] = args;
21997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21998 if (!SWIG_IsOK(res1)) {
21999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22000 }
22001 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22018 PyObject *resultobj = 0;
22019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22020 bool result;
22021 void *argp1 = 0 ;
22022 int res1 = 0 ;
22023 PyObject *swig_obj[1] ;
22024
22025 if (!args) SWIG_fail;
22026 swig_obj[0] = args;
22027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22030 }
22031 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22032 {
22033 PyThreadState* __tstate = wxPyBeginAllowThreads();
22034 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22035 wxPyEndAllowThreads(__tstate);
22036 if (PyErr_Occurred()) SWIG_fail;
22037 }
22038 {
22039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22040 }
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22048 PyObject *resultobj = 0;
22049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22050 bool result;
22051 void *argp1 = 0 ;
22052 int res1 = 0 ;
22053 PyObject *swig_obj[1] ;
22054
22055 if (!args) SWIG_fail;
22056 swig_obj[0] = args;
22057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22058 if (!SWIG_IsOK(res1)) {
22059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22060 }
22061 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 {
22069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22070 }
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22078 PyObject *resultobj = 0;
22079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22080 int result;
22081 void *argp1 = 0 ;
22082 int res1 = 0 ;
22083 PyObject *swig_obj[1] ;
22084
22085 if (!args) SWIG_fail;
22086 swig_obj[0] = args;
22087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22088 if (!SWIG_IsOK(res1)) {
22089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22090 }
22091 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22092 {
22093 PyThreadState* __tstate = wxPyBeginAllowThreads();
22094 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 resultobj = SWIG_From_int(static_cast< int >(result));
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22106 PyObject *resultobj = 0;
22107 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22108 int result;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 PyObject *swig_obj[1] ;
22112
22113 if (!args) SWIG_fail;
22114 swig_obj[0] = args;
22115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22116 if (!SWIG_IsOK(res1)) {
22117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22118 }
22119 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 resultobj = SWIG_From_int(static_cast< int >(result));
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22134 PyObject *resultobj = 0;
22135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22136 unsigned int result;
22137 void *argp1 = 0 ;
22138 int res1 = 0 ;
22139 PyObject *swig_obj[1] ;
22140
22141 if (!args) SWIG_fail;
22142 swig_obj[0] = args;
22143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22146 }
22147 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 PyObject *resultobj = 0;
22163 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22164 unsigned int result;
22165 void *argp1 = 0 ;
22166 int res1 = 0 ;
22167 PyObject *swig_obj[1] ;
22168
22169 if (!args) SWIG_fail;
22170 swig_obj[0] = args;
22171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22172 if (!SWIG_IsOK(res1)) {
22173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22174 }
22175 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 PyObject *resultobj = 0;
22191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22192 wxPoint result;
22193 void *argp1 = 0 ;
22194 int res1 = 0 ;
22195 PyObject *swig_obj[1] ;
22196
22197 if (!args) SWIG_fail;
22198 swig_obj[0] = args;
22199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22202 }
22203 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (arg1)->GetPosition();
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22218 PyObject *resultobj = 0;
22219 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22220 long *arg2 = (long *) 0 ;
22221 long *arg3 = (long *) 0 ;
22222 void *argp1 = 0 ;
22223 int res1 = 0 ;
22224 long temp2 ;
22225 int res2 = SWIG_TMPOBJ ;
22226 long temp3 ;
22227 int res3 = SWIG_TMPOBJ ;
22228 PyObject *swig_obj[1] ;
22229
22230 arg2 = &temp2;
22231 arg3 = &temp3;
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22237 }
22238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 (arg1)->GetPosition(arg2,arg3);
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 resultobj = SWIG_Py_Void();
22246 if (SWIG_IsTmpObj(res2)) {
22247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22248 } else {
22249 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22251 }
22252 if (SWIG_IsTmpObj(res3)) {
22253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22254 } else {
22255 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22257 }
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22265 PyObject *resultobj = 0;
22266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22267 int result;
22268 void *argp1 = 0 ;
22269 int res1 = 0 ;
22270 PyObject *swig_obj[1] ;
22271
22272 if (!args) SWIG_fail;
22273 swig_obj[0] = args;
22274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22275 if (!SWIG_IsOK(res1)) {
22276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22277 }
22278 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 result = (int)((wxKeyEvent const *)arg1)->GetX();
22282 wxPyEndAllowThreads(__tstate);
22283 if (PyErr_Occurred()) SWIG_fail;
22284 }
22285 resultobj = SWIG_From_int(static_cast< int >(result));
22286 return resultobj;
22287 fail:
22288 return NULL;
22289 }
22290
22291
22292 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22293 PyObject *resultobj = 0;
22294 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22295 int result;
22296 void *argp1 = 0 ;
22297 int res1 = 0 ;
22298 PyObject *swig_obj[1] ;
22299
22300 if (!args) SWIG_fail;
22301 swig_obj[0] = args;
22302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22303 if (!SWIG_IsOK(res1)) {
22304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22305 }
22306 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22307 {
22308 PyThreadState* __tstate = wxPyBeginAllowThreads();
22309 result = (int)((wxKeyEvent const *)arg1)->GetY();
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 resultobj = SWIG_From_int(static_cast< int >(result));
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *resultobj = 0;
22322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22323 int arg2 ;
22324 void *argp1 = 0 ;
22325 int res1 = 0 ;
22326 int val2 ;
22327 int ecode2 = 0 ;
22328 PyObject *swig_obj[2] ;
22329
22330 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22332 if (!SWIG_IsOK(res1)) {
22333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22334 }
22335 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22336 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22337 if (!SWIG_IsOK(ecode2)) {
22338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22339 }
22340 arg2 = static_cast< int >(val2);
22341 if (arg1) (arg1)->m_x = arg2;
22342
22343 resultobj = SWIG_Py_Void();
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22351 PyObject *resultobj = 0;
22352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22353 int result;
22354 void *argp1 = 0 ;
22355 int res1 = 0 ;
22356 PyObject *swig_obj[1] ;
22357
22358 if (!args) SWIG_fail;
22359 swig_obj[0] = args;
22360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22361 if (!SWIG_IsOK(res1)) {
22362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22363 }
22364 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22365 result = (int) ((arg1)->m_x);
22366 resultobj = SWIG_From_int(static_cast< int >(result));
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22374 PyObject *resultobj = 0;
22375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22376 int arg2 ;
22377 void *argp1 = 0 ;
22378 int res1 = 0 ;
22379 int val2 ;
22380 int ecode2 = 0 ;
22381 PyObject *swig_obj[2] ;
22382
22383 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22390 if (!SWIG_IsOK(ecode2)) {
22391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22392 }
22393 arg2 = static_cast< int >(val2);
22394 if (arg1) (arg1)->m_y = arg2;
22395
22396 resultobj = SWIG_Py_Void();
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22406 int result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 PyObject *swig_obj[1] ;
22410
22411 if (!args) SWIG_fail;
22412 swig_obj[0] = args;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22416 }
22417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22418 result = (int) ((arg1)->m_y);
22419 resultobj = SWIG_From_int(static_cast< int >(result));
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22427 PyObject *resultobj = 0;
22428 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22429 long arg2 ;
22430 void *argp1 = 0 ;
22431 int res1 = 0 ;
22432 long val2 ;
22433 int ecode2 = 0 ;
22434 PyObject *swig_obj[2] ;
22435
22436 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22438 if (!SWIG_IsOK(res1)) {
22439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22440 }
22441 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22442 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22443 if (!SWIG_IsOK(ecode2)) {
22444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22445 }
22446 arg2 = static_cast< long >(val2);
22447 if (arg1) (arg1)->m_keyCode = arg2;
22448
22449 resultobj = SWIG_Py_Void();
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 PyObject *resultobj = 0;
22458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22459 long result;
22460 void *argp1 = 0 ;
22461 int res1 = 0 ;
22462 PyObject *swig_obj[1] ;
22463
22464 if (!args) SWIG_fail;
22465 swig_obj[0] = args;
22466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22467 if (!SWIG_IsOK(res1)) {
22468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22469 }
22470 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22471 result = (long) ((arg1)->m_keyCode);
22472 resultobj = SWIG_From_long(static_cast< long >(result));
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *resultobj = 0;
22481 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22482 bool arg2 ;
22483 void *argp1 = 0 ;
22484 int res1 = 0 ;
22485 bool val2 ;
22486 int ecode2 = 0 ;
22487 PyObject *swig_obj[2] ;
22488
22489 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22491 if (!SWIG_IsOK(res1)) {
22492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22493 }
22494 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22495 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22496 if (!SWIG_IsOK(ecode2)) {
22497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22498 }
22499 arg2 = static_cast< bool >(val2);
22500 if (arg1) (arg1)->m_controlDown = arg2;
22501
22502 resultobj = SWIG_Py_Void();
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22510 PyObject *resultobj = 0;
22511 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22512 bool result;
22513 void *argp1 = 0 ;
22514 int res1 = 0 ;
22515 PyObject *swig_obj[1] ;
22516
22517 if (!args) SWIG_fail;
22518 swig_obj[0] = args;
22519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22520 if (!SWIG_IsOK(res1)) {
22521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22522 }
22523 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22524 result = (bool) ((arg1)->m_controlDown);
22525 {
22526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22527 }
22528 return resultobj;
22529 fail:
22530 return NULL;
22531 }
22532
22533
22534 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22535 PyObject *resultobj = 0;
22536 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22537 bool arg2 ;
22538 void *argp1 = 0 ;
22539 int res1 = 0 ;
22540 bool val2 ;
22541 int ecode2 = 0 ;
22542 PyObject *swig_obj[2] ;
22543
22544 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22546 if (!SWIG_IsOK(res1)) {
22547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22548 }
22549 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22550 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22551 if (!SWIG_IsOK(ecode2)) {
22552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22553 }
22554 arg2 = static_cast< bool >(val2);
22555 if (arg1) (arg1)->m_shiftDown = arg2;
22556
22557 resultobj = SWIG_Py_Void();
22558 return resultobj;
22559 fail:
22560 return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22565 PyObject *resultobj = 0;
22566 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22567 bool result;
22568 void *argp1 = 0 ;
22569 int res1 = 0 ;
22570 PyObject *swig_obj[1] ;
22571
22572 if (!args) SWIG_fail;
22573 swig_obj[0] = args;
22574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22575 if (!SWIG_IsOK(res1)) {
22576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22577 }
22578 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22579 result = (bool) ((arg1)->m_shiftDown);
22580 {
22581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22582 }
22583 return resultobj;
22584 fail:
22585 return NULL;
22586 }
22587
22588
22589 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22590 PyObject *resultobj = 0;
22591 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22592 bool arg2 ;
22593 void *argp1 = 0 ;
22594 int res1 = 0 ;
22595 bool val2 ;
22596 int ecode2 = 0 ;
22597 PyObject *swig_obj[2] ;
22598
22599 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22601 if (!SWIG_IsOK(res1)) {
22602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22603 }
22604 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22605 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22606 if (!SWIG_IsOK(ecode2)) {
22607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22608 }
22609 arg2 = static_cast< bool >(val2);
22610 if (arg1) (arg1)->m_altDown = arg2;
22611
22612 resultobj = SWIG_Py_Void();
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22620 PyObject *resultobj = 0;
22621 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22622 bool result;
22623 void *argp1 = 0 ;
22624 int res1 = 0 ;
22625 PyObject *swig_obj[1] ;
22626
22627 if (!args) SWIG_fail;
22628 swig_obj[0] = args;
22629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22630 if (!SWIG_IsOK(res1)) {
22631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22632 }
22633 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22634 result = (bool) ((arg1)->m_altDown);
22635 {
22636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22637 }
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22645 PyObject *resultobj = 0;
22646 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22647 bool arg2 ;
22648 void *argp1 = 0 ;
22649 int res1 = 0 ;
22650 bool val2 ;
22651 int ecode2 = 0 ;
22652 PyObject *swig_obj[2] ;
22653
22654 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22656 if (!SWIG_IsOK(res1)) {
22657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22658 }
22659 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22660 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22661 if (!SWIG_IsOK(ecode2)) {
22662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22663 }
22664 arg2 = static_cast< bool >(val2);
22665 if (arg1) (arg1)->m_metaDown = arg2;
22666
22667 resultobj = SWIG_Py_Void();
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22675 PyObject *resultobj = 0;
22676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22677 bool result;
22678 void *argp1 = 0 ;
22679 int res1 = 0 ;
22680 PyObject *swig_obj[1] ;
22681
22682 if (!args) SWIG_fail;
22683 swig_obj[0] = args;
22684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22685 if (!SWIG_IsOK(res1)) {
22686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22687 }
22688 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22689 result = (bool) ((arg1)->m_metaDown);
22690 {
22691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22692 }
22693 return resultobj;
22694 fail:
22695 return NULL;
22696 }
22697
22698
22699 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22700 PyObject *resultobj = 0;
22701 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22702 bool arg2 ;
22703 void *argp1 = 0 ;
22704 int res1 = 0 ;
22705 bool val2 ;
22706 int ecode2 = 0 ;
22707 PyObject *swig_obj[2] ;
22708
22709 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22711 if (!SWIG_IsOK(res1)) {
22712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22713 }
22714 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22715 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22716 if (!SWIG_IsOK(ecode2)) {
22717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22718 }
22719 arg2 = static_cast< bool >(val2);
22720 if (arg1) (arg1)->m_scanCode = arg2;
22721
22722 resultobj = SWIG_Py_Void();
22723 return resultobj;
22724 fail:
22725 return NULL;
22726 }
22727
22728
22729 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22730 PyObject *resultobj = 0;
22731 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22732 bool result;
22733 void *argp1 = 0 ;
22734 int res1 = 0 ;
22735 PyObject *swig_obj[1] ;
22736
22737 if (!args) SWIG_fail;
22738 swig_obj[0] = args;
22739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22740 if (!SWIG_IsOK(res1)) {
22741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22742 }
22743 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22744 result = (bool) ((arg1)->m_scanCode);
22745 {
22746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22747 }
22748 return resultobj;
22749 fail:
22750 return NULL;
22751 }
22752
22753
22754 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22755 PyObject *resultobj = 0;
22756 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22757 unsigned int arg2 ;
22758 void *argp1 = 0 ;
22759 int res1 = 0 ;
22760 unsigned int val2 ;
22761 int ecode2 = 0 ;
22762 PyObject *swig_obj[2] ;
22763
22764 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22766 if (!SWIG_IsOK(res1)) {
22767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22768 }
22769 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22770 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22771 if (!SWIG_IsOK(ecode2)) {
22772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22773 }
22774 arg2 = static_cast< unsigned int >(val2);
22775 if (arg1) (arg1)->m_rawCode = arg2;
22776
22777 resultobj = SWIG_Py_Void();
22778 return resultobj;
22779 fail:
22780 return NULL;
22781 }
22782
22783
22784 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22785 PyObject *resultobj = 0;
22786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22787 unsigned int result;
22788 void *argp1 = 0 ;
22789 int res1 = 0 ;
22790 PyObject *swig_obj[1] ;
22791
22792 if (!args) SWIG_fail;
22793 swig_obj[0] = args;
22794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22795 if (!SWIG_IsOK(res1)) {
22796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22797 }
22798 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22799 result = (unsigned int) ((arg1)->m_rawCode);
22800 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22801 return resultobj;
22802 fail:
22803 return NULL;
22804 }
22805
22806
22807 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22808 PyObject *resultobj = 0;
22809 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22810 unsigned int arg2 ;
22811 void *argp1 = 0 ;
22812 int res1 = 0 ;
22813 unsigned int val2 ;
22814 int ecode2 = 0 ;
22815 PyObject *swig_obj[2] ;
22816
22817 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22819 if (!SWIG_IsOK(res1)) {
22820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22821 }
22822 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22823 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22824 if (!SWIG_IsOK(ecode2)) {
22825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22826 }
22827 arg2 = static_cast< unsigned int >(val2);
22828 if (arg1) (arg1)->m_rawFlags = arg2;
22829
22830 resultobj = SWIG_Py_Void();
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22838 PyObject *resultobj = 0;
22839 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22840 unsigned int result;
22841 void *argp1 = 0 ;
22842 int res1 = 0 ;
22843 PyObject *swig_obj[1] ;
22844
22845 if (!args) SWIG_fail;
22846 swig_obj[0] = args;
22847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22848 if (!SWIG_IsOK(res1)) {
22849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22850 }
22851 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22852 result = (unsigned int) ((arg1)->m_rawFlags);
22853 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22854 return resultobj;
22855 fail:
22856 return NULL;
22857 }
22858
22859
22860 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22861 PyObject *obj;
22862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22863 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22864 return SWIG_Py_Void();
22865 }
22866
22867 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 return SWIG_Python_InitShadowInstance(args);
22869 }
22870
22871 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj = 0;
22873 wxSize const &arg1_defvalue = wxDefaultSize ;
22874 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22875 int arg2 = (int) 0 ;
22876 wxSizeEvent *result = 0 ;
22877 wxSize temp1 ;
22878 int val2 ;
22879 int ecode2 = 0 ;
22880 PyObject * obj0 = 0 ;
22881 PyObject * obj1 = 0 ;
22882 char * kwnames[] = {
22883 (char *) "sz",(char *) "winid", NULL
22884 };
22885
22886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22887 if (obj0) {
22888 {
22889 arg1 = &temp1;
22890 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22891 }
22892 }
22893 if (obj1) {
22894 ecode2 = SWIG_AsVal_int(obj1, &val2);
22895 if (!SWIG_IsOK(ecode2)) {
22896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22897 }
22898 arg2 = static_cast< int >(val2);
22899 }
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22903 wxPyEndAllowThreads(__tstate);
22904 if (PyErr_Occurred()) SWIG_fail;
22905 }
22906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22907 return resultobj;
22908 fail:
22909 return NULL;
22910 }
22911
22912
22913 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22914 PyObject *resultobj = 0;
22915 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22916 wxSize result;
22917 void *argp1 = 0 ;
22918 int res1 = 0 ;
22919 PyObject *swig_obj[1] ;
22920
22921 if (!args) SWIG_fail;
22922 swig_obj[0] = args;
22923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22926 }
22927 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22928 {
22929 PyThreadState* __tstate = wxPyBeginAllowThreads();
22930 result = ((wxSizeEvent const *)arg1)->GetSize();
22931 wxPyEndAllowThreads(__tstate);
22932 if (PyErr_Occurred()) SWIG_fail;
22933 }
22934 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22942 PyObject *resultobj = 0;
22943 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22944 wxRect result;
22945 void *argp1 = 0 ;
22946 int res1 = 0 ;
22947 PyObject *swig_obj[1] ;
22948
22949 if (!args) SWIG_fail;
22950 swig_obj[0] = args;
22951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22952 if (!SWIG_IsOK(res1)) {
22953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22954 }
22955 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 result = ((wxSizeEvent const *)arg1)->GetRect();
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22970 PyObject *resultobj = 0;
22971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22972 wxRect arg2 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 void *argp2 ;
22976 int res2 = 0 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "self",(char *) "rect", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22987 }
22988 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22989 {
22990 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22991 if (!SWIG_IsOK(res2)) {
22992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22993 }
22994 if (!argp2) {
22995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22996 } else {
22997 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22998 arg2 = *temp;
22999 if (SWIG_IsNewObj(res2)) delete temp;
23000 }
23001 }
23002 {
23003 PyThreadState* __tstate = wxPyBeginAllowThreads();
23004 (arg1)->SetRect(arg2);
23005 wxPyEndAllowThreads(__tstate);
23006 if (PyErr_Occurred()) SWIG_fail;
23007 }
23008 resultobj = SWIG_Py_Void();
23009 return resultobj;
23010 fail:
23011 return NULL;
23012 }
23013
23014
23015 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23016 PyObject *resultobj = 0;
23017 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23018 wxSize arg2 ;
23019 void *argp1 = 0 ;
23020 int res1 = 0 ;
23021 void *argp2 ;
23022 int res2 = 0 ;
23023 PyObject * obj0 = 0 ;
23024 PyObject * obj1 = 0 ;
23025 char * kwnames[] = {
23026 (char *) "self",(char *) "size", NULL
23027 };
23028
23029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23031 if (!SWIG_IsOK(res1)) {
23032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23033 }
23034 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23035 {
23036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23037 if (!SWIG_IsOK(res2)) {
23038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23039 }
23040 if (!argp2) {
23041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23042 } else {
23043 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23044 arg2 = *temp;
23045 if (SWIG_IsNewObj(res2)) delete temp;
23046 }
23047 }
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 wxSizeEvent_SetSize(arg1,arg2);
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_Py_Void();
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23064 wxSize *arg2 = (wxSize *) 0 ;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 void *argp2 = 0 ;
23068 int res2 = 0 ;
23069 PyObject *swig_obj[2] ;
23070
23071 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23073 if (!SWIG_IsOK(res1)) {
23074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23075 }
23076 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23077 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23078 if (!SWIG_IsOK(res2)) {
23079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23080 }
23081 arg2 = reinterpret_cast< wxSize * >(argp2);
23082 if (arg1) (arg1)->m_size = *arg2;
23083
23084 resultobj = SWIG_Py_Void();
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23092 PyObject *resultobj = 0;
23093 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23094 wxSize *result = 0 ;
23095 void *argp1 = 0 ;
23096 int res1 = 0 ;
23097 PyObject *swig_obj[1] ;
23098
23099 if (!args) SWIG_fail;
23100 swig_obj[0] = args;
23101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23102 if (!SWIG_IsOK(res1)) {
23103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23104 }
23105 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23106 result = (wxSize *)& ((arg1)->m_size);
23107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23115 PyObject *resultobj = 0;
23116 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23117 wxRect *arg2 = (wxRect *) 0 ;
23118 void *argp1 = 0 ;
23119 int res1 = 0 ;
23120 void *argp2 = 0 ;
23121 int res2 = 0 ;
23122 PyObject *swig_obj[2] ;
23123
23124 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23126 if (!SWIG_IsOK(res1)) {
23127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23128 }
23129 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23130 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23131 if (!SWIG_IsOK(res2)) {
23132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23133 }
23134 arg2 = reinterpret_cast< wxRect * >(argp2);
23135 if (arg1) (arg1)->m_rect = *arg2;
23136
23137 resultobj = SWIG_Py_Void();
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23145 PyObject *resultobj = 0;
23146 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23147 wxRect *result = 0 ;
23148 void *argp1 = 0 ;
23149 int res1 = 0 ;
23150 PyObject *swig_obj[1] ;
23151
23152 if (!args) SWIG_fail;
23153 swig_obj[0] = args;
23154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23155 if (!SWIG_IsOK(res1)) {
23156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23157 }
23158 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23159 result = (wxRect *)& ((arg1)->m_rect);
23160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *obj;
23169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23170 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23171 return SWIG_Py_Void();
23172 }
23173
23174 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23175 return SWIG_Python_InitShadowInstance(args);
23176 }
23177
23178 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj = 0;
23180 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23181 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23182 int arg2 = (int) 0 ;
23183 wxMoveEvent *result = 0 ;
23184 wxPoint temp1 ;
23185 int val2 ;
23186 int ecode2 = 0 ;
23187 PyObject * obj0 = 0 ;
23188 PyObject * obj1 = 0 ;
23189 char * kwnames[] = {
23190 (char *) "pos",(char *) "winid", NULL
23191 };
23192
23193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23194 if (obj0) {
23195 {
23196 arg1 = &temp1;
23197 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23198 }
23199 }
23200 if (obj1) {
23201 ecode2 = SWIG_AsVal_int(obj1, &val2);
23202 if (!SWIG_IsOK(ecode2)) {
23203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23204 }
23205 arg2 = static_cast< int >(val2);
23206 }
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23221 PyObject *resultobj = 0;
23222 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23223 wxPoint result;
23224 void *argp1 = 0 ;
23225 int res1 = 0 ;
23226 PyObject *swig_obj[1] ;
23227
23228 if (!args) SWIG_fail;
23229 swig_obj[0] = args;
23230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23231 if (!SWIG_IsOK(res1)) {
23232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23233 }
23234 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = ((wxMoveEvent const *)arg1)->GetPosition();
23238 wxPyEndAllowThreads(__tstate);
23239 if (PyErr_Occurred()) SWIG_fail;
23240 }
23241 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23242 return resultobj;
23243 fail:
23244 return NULL;
23245 }
23246
23247
23248 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23249 PyObject *resultobj = 0;
23250 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23251 wxRect result;
23252 void *argp1 = 0 ;
23253 int res1 = 0 ;
23254 PyObject *swig_obj[1] ;
23255
23256 if (!args) SWIG_fail;
23257 swig_obj[0] = args;
23258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23259 if (!SWIG_IsOK(res1)) {
23260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23261 }
23262 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 result = ((wxMoveEvent const *)arg1)->GetRect();
23266 wxPyEndAllowThreads(__tstate);
23267 if (PyErr_Occurred()) SWIG_fail;
23268 }
23269 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23270 return resultobj;
23271 fail:
23272 return NULL;
23273 }
23274
23275
23276 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23277 PyObject *resultobj = 0;
23278 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23279 wxRect *arg2 = 0 ;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 wxRect temp2 ;
23283 PyObject * obj0 = 0 ;
23284 PyObject * obj1 = 0 ;
23285 char * kwnames[] = {
23286 (char *) "self",(char *) "rect", NULL
23287 };
23288
23289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23291 if (!SWIG_IsOK(res1)) {
23292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23293 }
23294 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23295 {
23296 arg2 = &temp2;
23297 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23298 }
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 (arg1)->SetRect((wxRect const &)*arg2);
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 resultobj = SWIG_Py_Void();
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj = 0;
23314 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23315 wxPoint *arg2 = 0 ;
23316 void *argp1 = 0 ;
23317 int res1 = 0 ;
23318 wxPoint temp2 ;
23319 PyObject * obj0 = 0 ;
23320 PyObject * obj1 = 0 ;
23321 char * kwnames[] = {
23322 (char *) "self",(char *) "pos", NULL
23323 };
23324
23325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23327 if (!SWIG_IsOK(res1)) {
23328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23329 }
23330 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23331 {
23332 arg2 = &temp2;
23333 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23334 }
23335 {
23336 PyThreadState* __tstate = wxPyBeginAllowThreads();
23337 (arg1)->SetPosition((wxPoint const &)*arg2);
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 resultobj = SWIG_Py_Void();
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23349 PyObject *obj;
23350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23351 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23352 return SWIG_Py_Void();
23353 }
23354
23355 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23356 return SWIG_Python_InitShadowInstance(args);
23357 }
23358
23359 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 int arg1 = (int) 0 ;
23362 wxPaintEvent *result = 0 ;
23363 int val1 ;
23364 int ecode1 = 0 ;
23365 PyObject * obj0 = 0 ;
23366 char * kwnames[] = {
23367 (char *) "Id", NULL
23368 };
23369
23370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23371 if (obj0) {
23372 ecode1 = SWIG_AsVal_int(obj0, &val1);
23373 if (!SWIG_IsOK(ecode1)) {
23374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23375 }
23376 arg1 = static_cast< int >(val1);
23377 }
23378 {
23379 PyThreadState* __tstate = wxPyBeginAllowThreads();
23380 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23381 wxPyEndAllowThreads(__tstate);
23382 if (PyErr_Occurred()) SWIG_fail;
23383 }
23384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23392 PyObject *obj;
23393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23394 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23395 return SWIG_Py_Void();
23396 }
23397
23398 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23399 return SWIG_Python_InitShadowInstance(args);
23400 }
23401
23402 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj = 0;
23404 int arg1 = (int) 0 ;
23405 wxNcPaintEvent *result = 0 ;
23406 int val1 ;
23407 int ecode1 = 0 ;
23408 PyObject * obj0 = 0 ;
23409 char * kwnames[] = {
23410 (char *) "winid", NULL
23411 };
23412
23413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23414 if (obj0) {
23415 ecode1 = SWIG_AsVal_int(obj0, &val1);
23416 if (!SWIG_IsOK(ecode1)) {
23417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23418 }
23419 arg1 = static_cast< int >(val1);
23420 }
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 PyObject *obj;
23436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23437 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23438 return SWIG_Py_Void();
23439 }
23440
23441 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 return SWIG_Python_InitShadowInstance(args);
23443 }
23444
23445 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj = 0;
23447 int arg1 = (int) 0 ;
23448 wxDC *arg2 = (wxDC *) NULL ;
23449 wxEraseEvent *result = 0 ;
23450 int val1 ;
23451 int ecode1 = 0 ;
23452 void *argp2 = 0 ;
23453 int res2 = 0 ;
23454 PyObject * obj0 = 0 ;
23455 PyObject * obj1 = 0 ;
23456 char * kwnames[] = {
23457 (char *) "Id",(char *) "dc", NULL
23458 };
23459
23460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23461 if (obj0) {
23462 ecode1 = SWIG_AsVal_int(obj0, &val1);
23463 if (!SWIG_IsOK(ecode1)) {
23464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23465 }
23466 arg1 = static_cast< int >(val1);
23467 }
23468 if (obj1) {
23469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23470 if (!SWIG_IsOK(res2)) {
23471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23472 }
23473 arg2 = reinterpret_cast< wxDC * >(argp2);
23474 }
23475 {
23476 PyThreadState* __tstate = wxPyBeginAllowThreads();
23477 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23482 return resultobj;
23483 fail:
23484 return NULL;
23485 }
23486
23487
23488 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23489 PyObject *resultobj = 0;
23490 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23491 wxDC *result = 0 ;
23492 void *argp1 = 0 ;
23493 int res1 = 0 ;
23494 PyObject *swig_obj[1] ;
23495
23496 if (!args) SWIG_fail;
23497 swig_obj[0] = args;
23498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23499 if (!SWIG_IsOK(res1)) {
23500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23501 }
23502 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 {
23510 resultobj = wxPyMake_wxObject(result, (bool)0);
23511 }
23512 return resultobj;
23513 fail:
23514 return NULL;
23515 }
23516
23517
23518 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23519 PyObject *obj;
23520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23521 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23522 return SWIG_Py_Void();
23523 }
23524
23525 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23526 return SWIG_Python_InitShadowInstance(args);
23527 }
23528
23529 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj = 0;
23531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23532 int arg2 = (int) 0 ;
23533 wxFocusEvent *result = 0 ;
23534 int val1 ;
23535 int ecode1 = 0 ;
23536 int val2 ;
23537 int ecode2 = 0 ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 char * kwnames[] = {
23541 (char *) "type",(char *) "winid", NULL
23542 };
23543
23544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23545 if (obj0) {
23546 ecode1 = SWIG_AsVal_int(obj0, &val1);
23547 if (!SWIG_IsOK(ecode1)) {
23548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23549 }
23550 arg1 = static_cast< wxEventType >(val1);
23551 }
23552 if (obj1) {
23553 ecode2 = SWIG_AsVal_int(obj1, &val2);
23554 if (!SWIG_IsOK(ecode2)) {
23555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23556 }
23557 arg2 = static_cast< int >(val2);
23558 }
23559 {
23560 PyThreadState* __tstate = wxPyBeginAllowThreads();
23561 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 PyObject *resultobj = 0;
23574 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23575 wxWindow *result = 0 ;
23576 void *argp1 = 0 ;
23577 int res1 = 0 ;
23578 PyObject *swig_obj[1] ;
23579
23580 if (!args) SWIG_fail;
23581 swig_obj[0] = args;
23582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23583 if (!SWIG_IsOK(res1)) {
23584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23585 }
23586 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 {
23594 resultobj = wxPyMake_wxObject(result, (bool)0);
23595 }
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj = 0;
23604 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23605 wxWindow *arg2 = (wxWindow *) 0 ;
23606 void *argp1 = 0 ;
23607 int res1 = 0 ;
23608 void *argp2 = 0 ;
23609 int res2 = 0 ;
23610 PyObject * obj0 = 0 ;
23611 PyObject * obj1 = 0 ;
23612 char * kwnames[] = {
23613 (char *) "self",(char *) "win", NULL
23614 };
23615
23616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23618 if (!SWIG_IsOK(res1)) {
23619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23620 }
23621 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23623 if (!SWIG_IsOK(res2)) {
23624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23625 }
23626 arg2 = reinterpret_cast< wxWindow * >(argp2);
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 (arg1)->SetWindow(arg2);
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 resultobj = SWIG_Py_Void();
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23641 PyObject *obj;
23642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23643 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23644 return SWIG_Py_Void();
23645 }
23646
23647 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 return SWIG_Python_InitShadowInstance(args);
23649 }
23650
23651 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj = 0;
23653 wxWindow *arg1 = (wxWindow *) NULL ;
23654 wxChildFocusEvent *result = 0 ;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 PyObject * obj0 = 0 ;
23658 char * kwnames[] = {
23659 (char *) "win", NULL
23660 };
23661
23662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23663 if (obj0) {
23664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23665 if (!SWIG_IsOK(res1)) {
23666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23667 }
23668 arg1 = reinterpret_cast< wxWindow * >(argp1);
23669 }
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23684 PyObject *resultobj = 0;
23685 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23686 wxWindow *result = 0 ;
23687 void *argp1 = 0 ;
23688 int res1 = 0 ;
23689 PyObject *swig_obj[1] ;
23690
23691 if (!args) SWIG_fail;
23692 swig_obj[0] = args;
23693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23694 if (!SWIG_IsOK(res1)) {
23695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23696 }
23697 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23701 wxPyEndAllowThreads(__tstate);
23702 if (PyErr_Occurred()) SWIG_fail;
23703 }
23704 {
23705 resultobj = wxPyMake_wxObject(result, (bool)0);
23706 }
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *obj;
23715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23716 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23717 return SWIG_Py_Void();
23718 }
23719
23720 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 return SWIG_Python_InitShadowInstance(args);
23722 }
23723
23724 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = 0;
23726 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23727 bool arg2 = (bool) true ;
23728 int arg3 = (int) 0 ;
23729 wxActivateEvent *result = 0 ;
23730 int val1 ;
23731 int ecode1 = 0 ;
23732 bool val2 ;
23733 int ecode2 = 0 ;
23734 int val3 ;
23735 int ecode3 = 0 ;
23736 PyObject * obj0 = 0 ;
23737 PyObject * obj1 = 0 ;
23738 PyObject * obj2 = 0 ;
23739 char * kwnames[] = {
23740 (char *) "type",(char *) "active",(char *) "Id", NULL
23741 };
23742
23743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23744 if (obj0) {
23745 ecode1 = SWIG_AsVal_int(obj0, &val1);
23746 if (!SWIG_IsOK(ecode1)) {
23747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23748 }
23749 arg1 = static_cast< wxEventType >(val1);
23750 }
23751 if (obj1) {
23752 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23753 if (!SWIG_IsOK(ecode2)) {
23754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23755 }
23756 arg2 = static_cast< bool >(val2);
23757 }
23758 if (obj2) {
23759 ecode3 = SWIG_AsVal_int(obj2, &val3);
23760 if (!SWIG_IsOK(ecode3)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23762 }
23763 arg3 = static_cast< int >(val3);
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23779 PyObject *resultobj = 0;
23780 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23781 bool result;
23782 void *argp1 = 0 ;
23783 int res1 = 0 ;
23784 PyObject *swig_obj[1] ;
23785
23786 if (!args) SWIG_fail;
23787 swig_obj[0] = args;
23788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23789 if (!SWIG_IsOK(res1)) {
23790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23791 }
23792 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23796 wxPyEndAllowThreads(__tstate);
23797 if (PyErr_Occurred()) SWIG_fail;
23798 }
23799 {
23800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 int arg1 = (int) 0 ;
23822 wxInitDialogEvent *result = 0 ;
23823 int val1 ;
23824 int ecode1 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "Id", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23831 if (obj0) {
23832 ecode1 = SWIG_AsVal_int(obj0, &val1);
23833 if (!SWIG_IsOK(ecode1)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23835 }
23836 arg1 = static_cast< int >(val1);
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23852 PyObject *obj;
23853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23854 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23855 return SWIG_Py_Void();
23856 }
23857
23858 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23859 return SWIG_Python_InitShadowInstance(args);
23860 }
23861
23862 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23863 PyObject *resultobj = 0;
23864 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23865 int arg2 = (int) 0 ;
23866 wxMenu *arg3 = (wxMenu *) NULL ;
23867 wxMenuEvent *result = 0 ;
23868 int val1 ;
23869 int ecode1 = 0 ;
23870 int val2 ;
23871 int ecode2 = 0 ;
23872 void *argp3 = 0 ;
23873 int res3 = 0 ;
23874 PyObject * obj0 = 0 ;
23875 PyObject * obj1 = 0 ;
23876 PyObject * obj2 = 0 ;
23877 char * kwnames[] = {
23878 (char *) "type",(char *) "winid",(char *) "menu", NULL
23879 };
23880
23881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23882 if (obj0) {
23883 ecode1 = SWIG_AsVal_int(obj0, &val1);
23884 if (!SWIG_IsOK(ecode1)) {
23885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23886 }
23887 arg1 = static_cast< wxEventType >(val1);
23888 }
23889 if (obj1) {
23890 ecode2 = SWIG_AsVal_int(obj1, &val2);
23891 if (!SWIG_IsOK(ecode2)) {
23892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23893 }
23894 arg2 = static_cast< int >(val2);
23895 }
23896 if (obj2) {
23897 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23898 if (!SWIG_IsOK(res3)) {
23899 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23900 }
23901 arg3 = reinterpret_cast< wxMenu * >(argp3);
23902 }
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23906 wxPyEndAllowThreads(__tstate);
23907 if (PyErr_Occurred()) SWIG_fail;
23908 }
23909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23910 return resultobj;
23911 fail:
23912 return NULL;
23913 }
23914
23915
23916 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23917 PyObject *resultobj = 0;
23918 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23919 int result;
23920 void *argp1 = 0 ;
23921 int res1 = 0 ;
23922 PyObject *swig_obj[1] ;
23923
23924 if (!args) SWIG_fail;
23925 swig_obj[0] = args;
23926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23927 if (!SWIG_IsOK(res1)) {
23928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23929 }
23930 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23934 wxPyEndAllowThreads(__tstate);
23935 if (PyErr_Occurred()) SWIG_fail;
23936 }
23937 resultobj = SWIG_From_int(static_cast< int >(result));
23938 return resultobj;
23939 fail:
23940 return NULL;
23941 }
23942
23943
23944 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23945 PyObject *resultobj = 0;
23946 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23947 bool result;
23948 void *argp1 = 0 ;
23949 int res1 = 0 ;
23950 PyObject *swig_obj[1] ;
23951
23952 if (!args) SWIG_fail;
23953 swig_obj[0] = args;
23954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23955 if (!SWIG_IsOK(res1)) {
23956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23957 }
23958 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 {
23966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23967 }
23968 return resultobj;
23969 fail:
23970 return NULL;
23971 }
23972
23973
23974 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23975 PyObject *resultobj = 0;
23976 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23977 wxMenu *result = 0 ;
23978 void *argp1 = 0 ;
23979 int res1 = 0 ;
23980 PyObject *swig_obj[1] ;
23981
23982 if (!args) SWIG_fail;
23983 swig_obj[0] = args;
23984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23985 if (!SWIG_IsOK(res1)) {
23986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23987 }
23988 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23989 {
23990 PyThreadState* __tstate = wxPyBeginAllowThreads();
23991 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 {
23996 resultobj = wxPyMake_wxObject(result, (bool)0);
23997 }
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *obj;
24006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24008 return SWIG_Py_Void();
24009 }
24010
24011 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24012 return SWIG_Python_InitShadowInstance(args);
24013 }
24014
24015 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24016 PyObject *resultobj = 0;
24017 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24018 int arg2 = (int) 0 ;
24019 wxCloseEvent *result = 0 ;
24020 int val1 ;
24021 int ecode1 = 0 ;
24022 int val2 ;
24023 int ecode2 = 0 ;
24024 PyObject * obj0 = 0 ;
24025 PyObject * obj1 = 0 ;
24026 char * kwnames[] = {
24027 (char *) "type",(char *) "winid", NULL
24028 };
24029
24030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24031 if (obj0) {
24032 ecode1 = SWIG_AsVal_int(obj0, &val1);
24033 if (!SWIG_IsOK(ecode1)) {
24034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24035 }
24036 arg1 = static_cast< wxEventType >(val1);
24037 }
24038 if (obj1) {
24039 ecode2 = SWIG_AsVal_int(obj1, &val2);
24040 if (!SWIG_IsOK(ecode2)) {
24041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24042 }
24043 arg2 = static_cast< int >(val2);
24044 }
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24048 wxPyEndAllowThreads(__tstate);
24049 if (PyErr_Occurred()) SWIG_fail;
24050 }
24051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24052 return resultobj;
24053 fail:
24054 return NULL;
24055 }
24056
24057
24058 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24059 PyObject *resultobj = 0;
24060 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24061 bool arg2 ;
24062 void *argp1 = 0 ;
24063 int res1 = 0 ;
24064 bool val2 ;
24065 int ecode2 = 0 ;
24066 PyObject * obj0 = 0 ;
24067 PyObject * obj1 = 0 ;
24068 char * kwnames[] = {
24069 (char *) "self",(char *) "logOff", NULL
24070 };
24071
24072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24074 if (!SWIG_IsOK(res1)) {
24075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24076 }
24077 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24078 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24079 if (!SWIG_IsOK(ecode2)) {
24080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24081 }
24082 arg2 = static_cast< bool >(val2);
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 (arg1)->SetLoggingOff(arg2);
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_Py_Void();
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24099 bool result;
24100 void *argp1 = 0 ;
24101 int res1 = 0 ;
24102 PyObject *swig_obj[1] ;
24103
24104 if (!args) SWIG_fail;
24105 swig_obj[0] = args;
24106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24109 }
24110 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 {
24118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24119 }
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj = 0;
24128 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24129 bool arg2 = (bool) true ;
24130 void *argp1 = 0 ;
24131 int res1 = 0 ;
24132 bool val2 ;
24133 int ecode2 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 PyObject * obj1 = 0 ;
24136 char * kwnames[] = {
24137 (char *) "self",(char *) "veto", NULL
24138 };
24139
24140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24142 if (!SWIG_IsOK(res1)) {
24143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24144 }
24145 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24146 if (obj1) {
24147 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24148 if (!SWIG_IsOK(ecode2)) {
24149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24150 }
24151 arg2 = static_cast< bool >(val2);
24152 }
24153 {
24154 PyThreadState* __tstate = wxPyBeginAllowThreads();
24155 (arg1)->Veto(arg2);
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 resultobj = SWIG_Py_Void();
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24167 PyObject *resultobj = 0;
24168 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24169 bool result;
24170 void *argp1 = 0 ;
24171 int res1 = 0 ;
24172 PyObject *swig_obj[1] ;
24173
24174 if (!args) SWIG_fail;
24175 swig_obj[0] = args;
24176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24177 if (!SWIG_IsOK(res1)) {
24178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24179 }
24180 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24181 {
24182 PyThreadState* __tstate = wxPyBeginAllowThreads();
24183 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 {
24188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24189 }
24190 return resultobj;
24191 fail:
24192 return NULL;
24193 }
24194
24195
24196 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24197 PyObject *resultobj = 0;
24198 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24199 bool arg2 ;
24200 void *argp1 = 0 ;
24201 int res1 = 0 ;
24202 bool val2 ;
24203 int ecode2 = 0 ;
24204 PyObject * obj0 = 0 ;
24205 PyObject * obj1 = 0 ;
24206 char * kwnames[] = {
24207 (char *) "self",(char *) "canVeto", NULL
24208 };
24209
24210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24212 if (!SWIG_IsOK(res1)) {
24213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24214 }
24215 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24217 if (!SWIG_IsOK(ecode2)) {
24218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24219 }
24220 arg2 = static_cast< bool >(val2);
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 (arg1)->SetCanVeto(arg2);
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 resultobj = SWIG_Py_Void();
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24235 PyObject *resultobj = 0;
24236 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24237 bool result;
24238 void *argp1 = 0 ;
24239 int res1 = 0 ;
24240 PyObject *swig_obj[1] ;
24241
24242 if (!args) SWIG_fail;
24243 swig_obj[0] = args;
24244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24245 if (!SWIG_IsOK(res1)) {
24246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24247 }
24248 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24252 wxPyEndAllowThreads(__tstate);
24253 if (PyErr_Occurred()) SWIG_fail;
24254 }
24255 {
24256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24257 }
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *obj;
24266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24267 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24268 return SWIG_Py_Void();
24269 }
24270
24271 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24272 return SWIG_Python_InitShadowInstance(args);
24273 }
24274
24275 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24276 PyObject *resultobj = 0;
24277 int arg1 = (int) 0 ;
24278 bool arg2 = (bool) false ;
24279 wxShowEvent *result = 0 ;
24280 int val1 ;
24281 int ecode1 = 0 ;
24282 bool val2 ;
24283 int ecode2 = 0 ;
24284 PyObject * obj0 = 0 ;
24285 PyObject * obj1 = 0 ;
24286 char * kwnames[] = {
24287 (char *) "winid",(char *) "show", NULL
24288 };
24289
24290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24291 if (obj0) {
24292 ecode1 = SWIG_AsVal_int(obj0, &val1);
24293 if (!SWIG_IsOK(ecode1)) {
24294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24295 }
24296 arg1 = static_cast< int >(val1);
24297 }
24298 if (obj1) {
24299 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24300 if (!SWIG_IsOK(ecode2)) {
24301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24302 }
24303 arg2 = static_cast< bool >(val2);
24304 }
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj = 0;
24320 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24321 bool arg2 ;
24322 void *argp1 = 0 ;
24323 int res1 = 0 ;
24324 bool val2 ;
24325 int ecode2 = 0 ;
24326 PyObject * obj0 = 0 ;
24327 PyObject * obj1 = 0 ;
24328 char * kwnames[] = {
24329 (char *) "self",(char *) "show", NULL
24330 };
24331
24332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24334 if (!SWIG_IsOK(res1)) {
24335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24336 }
24337 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24338 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24339 if (!SWIG_IsOK(ecode2)) {
24340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24341 }
24342 arg2 = static_cast< bool >(val2);
24343 {
24344 PyThreadState* __tstate = wxPyBeginAllowThreads();
24345 (arg1)->SetShow(arg2);
24346 wxPyEndAllowThreads(__tstate);
24347 if (PyErr_Occurred()) SWIG_fail;
24348 }
24349 resultobj = SWIG_Py_Void();
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24357 PyObject *resultobj = 0;
24358 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24359 bool result;
24360 void *argp1 = 0 ;
24361 int res1 = 0 ;
24362 PyObject *swig_obj[1] ;
24363
24364 if (!args) SWIG_fail;
24365 swig_obj[0] = args;
24366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24369 }
24370 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24371 {
24372 PyThreadState* __tstate = wxPyBeginAllowThreads();
24373 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24374 wxPyEndAllowThreads(__tstate);
24375 if (PyErr_Occurred()) SWIG_fail;
24376 }
24377 {
24378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24379 }
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *obj;
24388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24389 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24390 return SWIG_Py_Void();
24391 }
24392
24393 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 return SWIG_Python_InitShadowInstance(args);
24395 }
24396
24397 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj = 0;
24399 int arg1 = (int) 0 ;
24400 bool arg2 = (bool) true ;
24401 wxIconizeEvent *result = 0 ;
24402 int val1 ;
24403 int ecode1 = 0 ;
24404 bool val2 ;
24405 int ecode2 = 0 ;
24406 PyObject * obj0 = 0 ;
24407 PyObject * obj1 = 0 ;
24408 char * kwnames[] = {
24409 (char *) "id",(char *) "iconized", NULL
24410 };
24411
24412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24413 if (obj0) {
24414 ecode1 = SWIG_AsVal_int(obj0, &val1);
24415 if (!SWIG_IsOK(ecode1)) {
24416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24417 }
24418 arg1 = static_cast< int >(val1);
24419 }
24420 if (obj1) {
24421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24422 if (!SWIG_IsOK(ecode2)) {
24423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24424 }
24425 arg2 = static_cast< bool >(val2);
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24430 wxPyEndAllowThreads(__tstate);
24431 if (PyErr_Occurred()) SWIG_fail;
24432 }
24433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24434 return resultobj;
24435 fail:
24436 return NULL;
24437 }
24438
24439
24440 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 PyObject *resultobj = 0;
24442 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24443 bool result;
24444 void *argp1 = 0 ;
24445 int res1 = 0 ;
24446 PyObject *swig_obj[1] ;
24447
24448 if (!args) SWIG_fail;
24449 swig_obj[0] = args;
24450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24453 }
24454 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (bool)(arg1)->Iconized();
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24471 PyObject *obj;
24472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24473 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24474 return SWIG_Py_Void();
24475 }
24476
24477 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 return SWIG_Python_InitShadowInstance(args);
24479 }
24480
24481 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj = 0;
24483 int arg1 = (int) 0 ;
24484 wxMaximizeEvent *result = 0 ;
24485 int val1 ;
24486 int ecode1 = 0 ;
24487 PyObject * obj0 = 0 ;
24488 char * kwnames[] = {
24489 (char *) "id", NULL
24490 };
24491
24492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24493 if (obj0) {
24494 ecode1 = SWIG_AsVal_int(obj0, &val1);
24495 if (!SWIG_IsOK(ecode1)) {
24496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24497 }
24498 arg1 = static_cast< int >(val1);
24499 }
24500 {
24501 PyThreadState* __tstate = wxPyBeginAllowThreads();
24502 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24503 wxPyEndAllowThreads(__tstate);
24504 if (PyErr_Occurred()) SWIG_fail;
24505 }
24506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24507 return resultobj;
24508 fail:
24509 return NULL;
24510 }
24511
24512
24513 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24514 PyObject *obj;
24515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24516 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24517 return SWIG_Py_Void();
24518 }
24519
24520 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24521 return SWIG_Python_InitShadowInstance(args);
24522 }
24523
24524 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24527 wxPoint result;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 PyObject *swig_obj[1] ;
24531
24532 if (!args) SWIG_fail;
24533 swig_obj[0] = args;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24537 }
24538 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (arg1)->GetPosition();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24546 return resultobj;
24547 fail:
24548 return NULL;
24549 }
24550
24551
24552 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24553 PyObject *resultobj = 0;
24554 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24555 int result;
24556 void *argp1 = 0 ;
24557 int res1 = 0 ;
24558 PyObject *swig_obj[1] ;
24559
24560 if (!args) SWIG_fail;
24561 swig_obj[0] = args;
24562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24565 }
24566 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24567 {
24568 PyThreadState* __tstate = wxPyBeginAllowThreads();
24569 result = (int)(arg1)->GetNumberOfFiles();
24570 wxPyEndAllowThreads(__tstate);
24571 if (PyErr_Occurred()) SWIG_fail;
24572 }
24573 resultobj = SWIG_From_int(static_cast< int >(result));
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24581 PyObject *resultobj = 0;
24582 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24583 PyObject *result = 0 ;
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_wxDropFilesEvent, 0 | 0 );
24591 if (!SWIG_IsOK(res1)) {
24592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24593 }
24594 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = result;
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24609 PyObject *obj;
24610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24611 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24612 return SWIG_Py_Void();
24613 }
24614
24615 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 int arg1 = (int) 0 ;
24618 wxUpdateUIEvent *result = 0 ;
24619 int val1 ;
24620 int ecode1 = 0 ;
24621 PyObject * obj0 = 0 ;
24622 char * kwnames[] = {
24623 (char *) "commandId", NULL
24624 };
24625
24626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24627 if (obj0) {
24628 ecode1 = SWIG_AsVal_int(obj0, &val1);
24629 if (!SWIG_IsOK(ecode1)) {
24630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24631 }
24632 arg1 = static_cast< int >(val1);
24633 }
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24637 wxPyEndAllowThreads(__tstate);
24638 if (PyErr_Occurred()) SWIG_fail;
24639 }
24640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24648 PyObject *resultobj = 0;
24649 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24650 bool result;
24651 void *argp1 = 0 ;
24652 int res1 = 0 ;
24653 PyObject *swig_obj[1] ;
24654
24655 if (!args) SWIG_fail;
24656 swig_obj[0] = args;
24657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24658 if (!SWIG_IsOK(res1)) {
24659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24660 }
24661 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24662 {
24663 PyThreadState* __tstate = wxPyBeginAllowThreads();
24664 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24665 wxPyEndAllowThreads(__tstate);
24666 if (PyErr_Occurred()) SWIG_fail;
24667 }
24668 {
24669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24670 }
24671 return resultobj;
24672 fail:
24673 return NULL;
24674 }
24675
24676
24677 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24678 PyObject *resultobj = 0;
24679 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24680 bool result;
24681 void *argp1 = 0 ;
24682 int res1 = 0 ;
24683 PyObject *swig_obj[1] ;
24684
24685 if (!args) SWIG_fail;
24686 swig_obj[0] = args;
24687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24688 if (!SWIG_IsOK(res1)) {
24689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24690 }
24691 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 {
24699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24700 }
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24708 PyObject *resultobj = 0;
24709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24710 bool result;
24711 void *argp1 = 0 ;
24712 int res1 = 0 ;
24713 PyObject *swig_obj[1] ;
24714
24715 if (!args) SWIG_fail;
24716 swig_obj[0] = args;
24717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24718 if (!SWIG_IsOK(res1)) {
24719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24720 }
24721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24725 wxPyEndAllowThreads(__tstate);
24726 if (PyErr_Occurred()) SWIG_fail;
24727 }
24728 {
24729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24730 }
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24738 PyObject *resultobj = 0;
24739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24740 wxString result;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 PyObject *swig_obj[1] ;
24744
24745 if (!args) SWIG_fail;
24746 swig_obj[0] = args;
24747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24748 if (!SWIG_IsOK(res1)) {
24749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24750 }
24751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 #if wxUSE_UNICODE
24760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24761 #else
24762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24763 #endif
24764 }
24765 return resultobj;
24766 fail:
24767 return NULL;
24768 }
24769
24770
24771 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24772 PyObject *resultobj = 0;
24773 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24774 bool result;
24775 void *argp1 = 0 ;
24776 int res1 = 0 ;
24777 PyObject *swig_obj[1] ;
24778
24779 if (!args) SWIG_fail;
24780 swig_obj[0] = args;
24781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24782 if (!SWIG_IsOK(res1)) {
24783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24784 }
24785 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 {
24793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24794 }
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24802 PyObject *resultobj = 0;
24803 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24804 bool result;
24805 void *argp1 = 0 ;
24806 int res1 = 0 ;
24807 PyObject *swig_obj[1] ;
24808
24809 if (!args) SWIG_fail;
24810 swig_obj[0] = args;
24811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24812 if (!SWIG_IsOK(res1)) {
24813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24814 }
24815 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24832 PyObject *resultobj = 0;
24833 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24834 bool result;
24835 void *argp1 = 0 ;
24836 int res1 = 0 ;
24837 PyObject *swig_obj[1] ;
24838
24839 if (!args) SWIG_fail;
24840 swig_obj[0] = args;
24841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24842 if (!SWIG_IsOK(res1)) {
24843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24844 }
24845 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24864 bool 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_wxUpdateUIEvent, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24874 }
24875 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 {
24883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24884 }
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24892 PyObject *resultobj = 0;
24893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24894 bool arg2 ;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 bool val2 ;
24898 int ecode2 = 0 ;
24899 PyObject * obj0 = 0 ;
24900 PyObject * obj1 = 0 ;
24901 char * kwnames[] = {
24902 (char *) "self",(char *) "check", NULL
24903 };
24904
24905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24907 if (!SWIG_IsOK(res1)) {
24908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24909 }
24910 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24912 if (!SWIG_IsOK(ecode2)) {
24913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24914 }
24915 arg2 = static_cast< bool >(val2);
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 (arg1)->Check(arg2);
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 resultobj = SWIG_Py_Void();
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24932 bool arg2 ;
24933 void *argp1 = 0 ;
24934 int res1 = 0 ;
24935 bool val2 ;
24936 int ecode2 = 0 ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "enable", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24947 }
24948 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24950 if (!SWIG_IsOK(ecode2)) {
24951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24952 }
24953 arg2 = static_cast< bool >(val2);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 (arg1)->Enable(arg2);
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 resultobj = SWIG_Py_Void();
24961 return resultobj;
24962 fail:
24963 return NULL;
24964 }
24965
24966
24967 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24968 PyObject *resultobj = 0;
24969 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24970 bool arg2 ;
24971 void *argp1 = 0 ;
24972 int res1 = 0 ;
24973 bool val2 ;
24974 int ecode2 = 0 ;
24975 PyObject * obj0 = 0 ;
24976 PyObject * obj1 = 0 ;
24977 char * kwnames[] = {
24978 (char *) "self",(char *) "show", NULL
24979 };
24980
24981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24983 if (!SWIG_IsOK(res1)) {
24984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24985 }
24986 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24988 if (!SWIG_IsOK(ecode2)) {
24989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24990 }
24991 arg2 = static_cast< bool >(val2);
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 (arg1)->Show(arg2);
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 resultobj = SWIG_Py_Void();
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25006 PyObject *resultobj = 0;
25007 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25008 wxString *arg2 = 0 ;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 bool temp2 = false ;
25012 PyObject * obj0 = 0 ;
25013 PyObject * obj1 = 0 ;
25014 char * kwnames[] = {
25015 (char *) "self",(char *) "text", NULL
25016 };
25017
25018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25020 if (!SWIG_IsOK(res1)) {
25021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25022 }
25023 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25024 {
25025 arg2 = wxString_in_helper(obj1);
25026 if (arg2 == NULL) SWIG_fail;
25027 temp2 = true;
25028 }
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 (arg1)->SetText((wxString const &)*arg2);
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 resultobj = SWIG_Py_Void();
25036 {
25037 if (temp2)
25038 delete arg2;
25039 }
25040 return resultobj;
25041 fail:
25042 {
25043 if (temp2)
25044 delete arg2;
25045 }
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj = 0;
25052 long arg1 ;
25053 long val1 ;
25054 int ecode1 = 0 ;
25055 PyObject * obj0 = 0 ;
25056 char * kwnames[] = {
25057 (char *) "updateInterval", NULL
25058 };
25059
25060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25061 ecode1 = SWIG_AsVal_long(obj0, &val1);
25062 if (!SWIG_IsOK(ecode1)) {
25063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25064 }
25065 arg1 = static_cast< long >(val1);
25066 {
25067 PyThreadState* __tstate = wxPyBeginAllowThreads();
25068 wxUpdateUIEvent::SetUpdateInterval(arg1);
25069 wxPyEndAllowThreads(__tstate);
25070 if (PyErr_Occurred()) SWIG_fail;
25071 }
25072 resultobj = SWIG_Py_Void();
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25080 PyObject *resultobj = 0;
25081 long result;
25082
25083 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_From_long(static_cast< long >(result));
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxWindow *arg1 = (wxWindow *) 0 ;
25100 bool result;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 PyObject * obj0 = 0 ;
25104 char * kwnames[] = {
25105 (char *) "win", NULL
25106 };
25107
25108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25110 if (!SWIG_IsOK(res1)) {
25111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25112 }
25113 arg1 = reinterpret_cast< wxWindow * >(argp1);
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 {
25121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25122 }
25123 return resultobj;
25124 fail:
25125 return NULL;
25126 }
25127
25128
25129 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130 PyObject *resultobj = 0;
25131
25132 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 wxUpdateUIEvent::ResetUpdateTime();
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 resultobj = SWIG_Py_Void();
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj = 0;
25148 wxUpdateUIMode arg1 ;
25149 int val1 ;
25150 int ecode1 = 0 ;
25151 PyObject * obj0 = 0 ;
25152 char * kwnames[] = {
25153 (char *) "mode", NULL
25154 };
25155
25156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25157 ecode1 = SWIG_AsVal_int(obj0, &val1);
25158 if (!SWIG_IsOK(ecode1)) {
25159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25160 }
25161 arg1 = static_cast< wxUpdateUIMode >(val1);
25162 {
25163 PyThreadState* __tstate = wxPyBeginAllowThreads();
25164 wxUpdateUIEvent::SetMode(arg1);
25165 wxPyEndAllowThreads(__tstate);
25166 if (PyErr_Occurred()) SWIG_fail;
25167 }
25168 resultobj = SWIG_Py_Void();
25169 return resultobj;
25170 fail:
25171 return NULL;
25172 }
25173
25174
25175 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25176 PyObject *resultobj = 0;
25177 wxUpdateUIMode result;
25178
25179 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_From_int(static_cast< int >(result));
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25194 PyObject *obj;
25195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25196 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25197 return SWIG_Py_Void();
25198 }
25199
25200 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25201 return SWIG_Python_InitShadowInstance(args);
25202 }
25203
25204 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25205 PyObject *resultobj = 0;
25206 wxSysColourChangedEvent *result = 0 ;
25207
25208 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25209 {
25210 PyThreadState* __tstate = wxPyBeginAllowThreads();
25211 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25216 return resultobj;
25217 fail:
25218 return NULL;
25219 }
25220
25221
25222 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25223 PyObject *obj;
25224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25225 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25226 return SWIG_Py_Void();
25227 }
25228
25229 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25230 return SWIG_Python_InitShadowInstance(args);
25231 }
25232
25233 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj = 0;
25235 int arg1 = (int) 0 ;
25236 wxWindow *arg2 = (wxWindow *) NULL ;
25237 wxMouseCaptureChangedEvent *result = 0 ;
25238 int val1 ;
25239 int ecode1 = 0 ;
25240 void *argp2 = 0 ;
25241 int res2 = 0 ;
25242 PyObject * obj0 = 0 ;
25243 PyObject * obj1 = 0 ;
25244 char * kwnames[] = {
25245 (char *) "winid",(char *) "gainedCapture", NULL
25246 };
25247
25248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25249 if (obj0) {
25250 ecode1 = SWIG_AsVal_int(obj0, &val1);
25251 if (!SWIG_IsOK(ecode1)) {
25252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25253 }
25254 arg1 = static_cast< int >(val1);
25255 }
25256 if (obj1) {
25257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25258 if (!SWIG_IsOK(res2)) {
25259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25260 }
25261 arg2 = reinterpret_cast< wxWindow * >(argp2);
25262 }
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 PyObject *resultobj = 0;
25278 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25279 wxWindow *result = 0 ;
25280 void *argp1 = 0 ;
25281 int res1 = 0 ;
25282 PyObject *swig_obj[1] ;
25283
25284 if (!args) SWIG_fail;
25285 swig_obj[0] = args;
25286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25287 if (!SWIG_IsOK(res1)) {
25288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25289 }
25290 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 {
25298 resultobj = wxPyMake_wxObject(result, (bool)0);
25299 }
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25307 PyObject *obj;
25308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25309 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25310 return SWIG_Py_Void();
25311 }
25312
25313 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25314 return SWIG_Python_InitShadowInstance(args);
25315 }
25316
25317 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25318 PyObject *resultobj = 0;
25319 wxDisplayChangedEvent *result = 0 ;
25320
25321 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *obj;
25337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25338 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25339 return SWIG_Py_Void();
25340 }
25341
25342 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25343 return SWIG_Python_InitShadowInstance(args);
25344 }
25345
25346 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25347 PyObject *resultobj = 0;
25348 int arg1 = (int) 0 ;
25349 wxPaletteChangedEvent *result = 0 ;
25350 int val1 ;
25351 int ecode1 = 0 ;
25352 PyObject * obj0 = 0 ;
25353 char * kwnames[] = {
25354 (char *) "id", NULL
25355 };
25356
25357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25358 if (obj0) {
25359 ecode1 = SWIG_AsVal_int(obj0, &val1);
25360 if (!SWIG_IsOK(ecode1)) {
25361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25362 }
25363 arg1 = static_cast< int >(val1);
25364 }
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj = 0;
25380 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25381 wxWindow *arg2 = (wxWindow *) 0 ;
25382 void *argp1 = 0 ;
25383 int res1 = 0 ;
25384 void *argp2 = 0 ;
25385 int res2 = 0 ;
25386 PyObject * obj0 = 0 ;
25387 PyObject * obj1 = 0 ;
25388 char * kwnames[] = {
25389 (char *) "self",(char *) "win", NULL
25390 };
25391
25392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25394 if (!SWIG_IsOK(res1)) {
25395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25396 }
25397 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25399 if (!SWIG_IsOK(res2)) {
25400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25401 }
25402 arg2 = reinterpret_cast< wxWindow * >(argp2);
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 (arg1)->SetChangedWindow(arg2);
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 resultobj = SWIG_Py_Void();
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25417 PyObject *resultobj = 0;
25418 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25419 wxWindow *result = 0 ;
25420 void *argp1 = 0 ;
25421 int res1 = 0 ;
25422 PyObject *swig_obj[1] ;
25423
25424 if (!args) SWIG_fail;
25425 swig_obj[0] = args;
25426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25427 if (!SWIG_IsOK(res1)) {
25428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25429 }
25430 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (wxWindow *)(arg1)->GetChangedWindow();
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 {
25438 resultobj = wxPyMake_wxObject(result, (bool)0);
25439 }
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25447 PyObject *obj;
25448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25449 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25450 return SWIG_Py_Void();
25451 }
25452
25453 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25454 return SWIG_Python_InitShadowInstance(args);
25455 }
25456
25457 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25458 PyObject *resultobj = 0;
25459 int arg1 = (int) 0 ;
25460 wxQueryNewPaletteEvent *result = 0 ;
25461 int val1 ;
25462 int ecode1 = 0 ;
25463 PyObject * obj0 = 0 ;
25464 char * kwnames[] = {
25465 (char *) "winid", NULL
25466 };
25467
25468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25469 if (obj0) {
25470 ecode1 = SWIG_AsVal_int(obj0, &val1);
25471 if (!SWIG_IsOK(ecode1)) {
25472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25473 }
25474 arg1 = static_cast< int >(val1);
25475 }
25476 {
25477 PyThreadState* __tstate = wxPyBeginAllowThreads();
25478 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25483 return resultobj;
25484 fail:
25485 return NULL;
25486 }
25487
25488
25489 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25490 PyObject *resultobj = 0;
25491 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25492 bool arg2 ;
25493 void *argp1 = 0 ;
25494 int res1 = 0 ;
25495 bool val2 ;
25496 int ecode2 = 0 ;
25497 PyObject * obj0 = 0 ;
25498 PyObject * obj1 = 0 ;
25499 char * kwnames[] = {
25500 (char *) "self",(char *) "realized", NULL
25501 };
25502
25503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25505 if (!SWIG_IsOK(res1)) {
25506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25507 }
25508 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25510 if (!SWIG_IsOK(ecode2)) {
25511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25512 }
25513 arg2 = static_cast< bool >(val2);
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 (arg1)->SetPaletteRealized(arg2);
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 resultobj = SWIG_Py_Void();
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25528 PyObject *resultobj = 0;
25529 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25530 bool result;
25531 void *argp1 = 0 ;
25532 int res1 = 0 ;
25533 PyObject *swig_obj[1] ;
25534
25535 if (!args) SWIG_fail;
25536 swig_obj[0] = args;
25537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25538 if (!SWIG_IsOK(res1)) {
25539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25540 }
25541 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 {
25549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25550 }
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25558 PyObject *obj;
25559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25560 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25561 return SWIG_Py_Void();
25562 }
25563
25564 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25565 return SWIG_Python_InitShadowInstance(args);
25566 }
25567
25568 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25569 PyObject *resultobj = 0;
25570 wxNavigationKeyEvent *result = 0 ;
25571
25572 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25589 bool result;
25590 void *argp1 = 0 ;
25591 int res1 = 0 ;
25592 PyObject *swig_obj[1] ;
25593
25594 if (!args) SWIG_fail;
25595 swig_obj[0] = args;
25596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25597 if (!SWIG_IsOK(res1)) {
25598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25599 }
25600 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25604 wxPyEndAllowThreads(__tstate);
25605 if (PyErr_Occurred()) SWIG_fail;
25606 }
25607 {
25608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25609 }
25610 return resultobj;
25611 fail:
25612 return NULL;
25613 }
25614
25615
25616 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25617 PyObject *resultobj = 0;
25618 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25619 bool arg2 ;
25620 void *argp1 = 0 ;
25621 int res1 = 0 ;
25622 bool val2 ;
25623 int ecode2 = 0 ;
25624 PyObject * obj0 = 0 ;
25625 PyObject * obj1 = 0 ;
25626 char * kwnames[] = {
25627 (char *) "self",(char *) "forward", NULL
25628 };
25629
25630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25634 }
25635 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25636 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25637 if (!SWIG_IsOK(ecode2)) {
25638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25639 }
25640 arg2 = static_cast< bool >(val2);
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 (arg1)->SetDirection(arg2);
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 resultobj = SWIG_Py_Void();
25648 return resultobj;
25649 fail:
25650 return NULL;
25651 }
25652
25653
25654 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25655 PyObject *resultobj = 0;
25656 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25657 bool result;
25658 void *argp1 = 0 ;
25659 int res1 = 0 ;
25660 PyObject *swig_obj[1] ;
25661
25662 if (!args) SWIG_fail;
25663 swig_obj[0] = args;
25664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25665 if (!SWIG_IsOK(res1)) {
25666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25667 }
25668 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25669 {
25670 PyThreadState* __tstate = wxPyBeginAllowThreads();
25671 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25672 wxPyEndAllowThreads(__tstate);
25673 if (PyErr_Occurred()) SWIG_fail;
25674 }
25675 {
25676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25677 }
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25685 PyObject *resultobj = 0;
25686 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25687 bool arg2 ;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 bool val2 ;
25691 int ecode2 = 0 ;
25692 PyObject * obj0 = 0 ;
25693 PyObject * obj1 = 0 ;
25694 char * kwnames[] = {
25695 (char *) "self",(char *) "ischange", NULL
25696 };
25697
25698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25702 }
25703 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25705 if (!SWIG_IsOK(ecode2)) {
25706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25707 }
25708 arg2 = static_cast< bool >(val2);
25709 {
25710 PyThreadState* __tstate = wxPyBeginAllowThreads();
25711 (arg1)->SetWindowChange(arg2);
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 resultobj = SWIG_Py_Void();
25716 return resultobj;
25717 fail:
25718 return NULL;
25719 }
25720
25721
25722 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25723 PyObject *resultobj = 0;
25724 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25725 bool result;
25726 void *argp1 = 0 ;
25727 int res1 = 0 ;
25728 PyObject *swig_obj[1] ;
25729
25730 if (!args) SWIG_fail;
25731 swig_obj[0] = args;
25732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25733 if (!SWIG_IsOK(res1)) {
25734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25735 }
25736 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25737 {
25738 PyThreadState* __tstate = wxPyBeginAllowThreads();
25739 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj = 0;
25754 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25755 bool arg2 ;
25756 void *argp1 = 0 ;
25757 int res1 = 0 ;
25758 bool val2 ;
25759 int ecode2 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 PyObject * obj1 = 0 ;
25762 char * kwnames[] = {
25763 (char *) "self",(char *) "bIs", NULL
25764 };
25765
25766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25768 if (!SWIG_IsOK(res1)) {
25769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25770 }
25771 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25773 if (!SWIG_IsOK(ecode2)) {
25774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25775 }
25776 arg2 = static_cast< bool >(val2);
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 (arg1)->SetFromTab(arg2);
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 resultobj = SWIG_Py_Void();
25784 return resultobj;
25785 fail:
25786 return NULL;
25787 }
25788
25789
25790 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25791 PyObject *resultobj = 0;
25792 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25793 long arg2 ;
25794 void *argp1 = 0 ;
25795 int res1 = 0 ;
25796 long val2 ;
25797 int ecode2 = 0 ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char * kwnames[] = {
25801 (char *) "self",(char *) "flags", NULL
25802 };
25803
25804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25806 if (!SWIG_IsOK(res1)) {
25807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25808 }
25809 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25810 ecode2 = SWIG_AsVal_long(obj1, &val2);
25811 if (!SWIG_IsOK(ecode2)) {
25812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25813 }
25814 arg2 = static_cast< long >(val2);
25815 {
25816 PyThreadState* __tstate = wxPyBeginAllowThreads();
25817 (arg1)->SetFlags(arg2);
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 resultobj = SWIG_Py_Void();
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 PyObject *resultobj = 0;
25830 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25831 wxWindow *result = 0 ;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 PyObject *swig_obj[1] ;
25835
25836 if (!args) SWIG_fail;
25837 swig_obj[0] = args;
25838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25839 if (!SWIG_IsOK(res1)) {
25840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25841 }
25842 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 {
25850 resultobj = wxPyMake_wxObject(result, (bool)0);
25851 }
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj = 0;
25860 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25861 wxWindow *arg2 = (wxWindow *) 0 ;
25862 void *argp1 = 0 ;
25863 int res1 = 0 ;
25864 void *argp2 = 0 ;
25865 int res2 = 0 ;
25866 PyObject * obj0 = 0 ;
25867 PyObject * obj1 = 0 ;
25868 char * kwnames[] = {
25869 (char *) "self",(char *) "win", NULL
25870 };
25871
25872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25874 if (!SWIG_IsOK(res1)) {
25875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25876 }
25877 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25879 if (!SWIG_IsOK(res2)) {
25880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25881 }
25882 arg2 = reinterpret_cast< wxWindow * >(argp2);
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 (arg1)->SetCurrentFocus(arg2);
25886 wxPyEndAllowThreads(__tstate);
25887 if (PyErr_Occurred()) SWIG_fail;
25888 }
25889 resultobj = SWIG_Py_Void();
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25897 PyObject *obj;
25898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25899 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25900 return SWIG_Py_Void();
25901 }
25902
25903 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25904 return SWIG_Python_InitShadowInstance(args);
25905 }
25906
25907 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj = 0;
25909 wxWindow *arg1 = (wxWindow *) NULL ;
25910 wxWindowCreateEvent *result = 0 ;
25911 void *argp1 = 0 ;
25912 int res1 = 0 ;
25913 PyObject * obj0 = 0 ;
25914 char * kwnames[] = {
25915 (char *) "win", NULL
25916 };
25917
25918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25919 if (obj0) {
25920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25921 if (!SWIG_IsOK(res1)) {
25922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25923 }
25924 arg1 = reinterpret_cast< wxWindow * >(argp1);
25925 }
25926 {
25927 PyThreadState* __tstate = wxPyBeginAllowThreads();
25928 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25929 wxPyEndAllowThreads(__tstate);
25930 if (PyErr_Occurred()) SWIG_fail;
25931 }
25932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25933 return resultobj;
25934 fail:
25935 return NULL;
25936 }
25937
25938
25939 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25940 PyObject *resultobj = 0;
25941 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25942 wxWindow *result = 0 ;
25943 void *argp1 = 0 ;
25944 int res1 = 0 ;
25945 PyObject *swig_obj[1] ;
25946
25947 if (!args) SWIG_fail;
25948 swig_obj[0] = args;
25949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25950 if (!SWIG_IsOK(res1)) {
25951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25952 }
25953 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25957 wxPyEndAllowThreads(__tstate);
25958 if (PyErr_Occurred()) SWIG_fail;
25959 }
25960 {
25961 resultobj = wxPyMake_wxObject(result, (bool)0);
25962 }
25963 return resultobj;
25964 fail:
25965 return NULL;
25966 }
25967
25968
25969 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25970 PyObject *obj;
25971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25972 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25973 return SWIG_Py_Void();
25974 }
25975
25976 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 return SWIG_Python_InitShadowInstance(args);
25978 }
25979
25980 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj = 0;
25982 wxWindow *arg1 = (wxWindow *) NULL ;
25983 wxWindowDestroyEvent *result = 0 ;
25984 void *argp1 = 0 ;
25985 int res1 = 0 ;
25986 PyObject * obj0 = 0 ;
25987 char * kwnames[] = {
25988 (char *) "win", NULL
25989 };
25990
25991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25992 if (obj0) {
25993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25994 if (!SWIG_IsOK(res1)) {
25995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25996 }
25997 arg1 = reinterpret_cast< wxWindow * >(argp1);
25998 }
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26002 wxPyEndAllowThreads(__tstate);
26003 if (PyErr_Occurred()) SWIG_fail;
26004 }
26005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26006 return resultobj;
26007 fail:
26008 return NULL;
26009 }
26010
26011
26012 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26013 PyObject *resultobj = 0;
26014 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26015 wxWindow *result = 0 ;
26016 void *argp1 = 0 ;
26017 int res1 = 0 ;
26018 PyObject *swig_obj[1] ;
26019
26020 if (!args) SWIG_fail;
26021 swig_obj[0] = args;
26022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26023 if (!SWIG_IsOK(res1)) {
26024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26025 }
26026 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 {
26034 resultobj = wxPyMake_wxObject(result, (bool)0);
26035 }
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26043 PyObject *obj;
26044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26045 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26046 return SWIG_Py_Void();
26047 }
26048
26049 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26050 return SWIG_Python_InitShadowInstance(args);
26051 }
26052
26053 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26054 PyObject *resultobj = 0;
26055 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26056 int arg2 = (int) 0 ;
26057 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26058 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26059 wxContextMenuEvent *result = 0 ;
26060 int val1 ;
26061 int ecode1 = 0 ;
26062 int val2 ;
26063 int ecode2 = 0 ;
26064 wxPoint temp3 ;
26065 PyObject * obj0 = 0 ;
26066 PyObject * obj1 = 0 ;
26067 PyObject * obj2 = 0 ;
26068 char * kwnames[] = {
26069 (char *) "type",(char *) "winid",(char *) "pt", NULL
26070 };
26071
26072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26073 if (obj0) {
26074 ecode1 = SWIG_AsVal_int(obj0, &val1);
26075 if (!SWIG_IsOK(ecode1)) {
26076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26077 }
26078 arg1 = static_cast< wxEventType >(val1);
26079 }
26080 if (obj1) {
26081 ecode2 = SWIG_AsVal_int(obj1, &val2);
26082 if (!SWIG_IsOK(ecode2)) {
26083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26084 }
26085 arg2 = static_cast< int >(val2);
26086 }
26087 if (obj2) {
26088 {
26089 arg3 = &temp3;
26090 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26091 }
26092 }
26093 {
26094 PyThreadState* __tstate = wxPyBeginAllowThreads();
26095 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26109 wxPoint *result = 0 ;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26119 }
26120 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 {
26124 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26125 result = (wxPoint *) &_result_ref;
26126 }
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26138 PyObject *resultobj = 0;
26139 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26140 wxPoint *arg2 = 0 ;
26141 void *argp1 = 0 ;
26142 int res1 = 0 ;
26143 wxPoint temp2 ;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "self",(char *) "pos", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26152 if (!SWIG_IsOK(res1)) {
26153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26154 }
26155 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26156 {
26157 arg2 = &temp2;
26158 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26159 }
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 (arg1)->SetPosition((wxPoint const &)*arg2);
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_Py_Void();
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26174 PyObject *obj;
26175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26176 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26177 return SWIG_Py_Void();
26178 }
26179
26180 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26181 return SWIG_Python_InitShadowInstance(args);
26182 }
26183
26184 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26185 PyObject *resultobj = 0;
26186 wxIdleEvent *result = 0 ;
26187
26188 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26189 {
26190 PyThreadState* __tstate = wxPyBeginAllowThreads();
26191 result = (wxIdleEvent *)new wxIdleEvent();
26192 wxPyEndAllowThreads(__tstate);
26193 if (PyErr_Occurred()) SWIG_fail;
26194 }
26195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26196 return resultobj;
26197 fail:
26198 return NULL;
26199 }
26200
26201
26202 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26203 PyObject *resultobj = 0;
26204 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26205 bool arg2 = (bool) true ;
26206 void *argp1 = 0 ;
26207 int res1 = 0 ;
26208 bool val2 ;
26209 int ecode2 = 0 ;
26210 PyObject * obj0 = 0 ;
26211 PyObject * obj1 = 0 ;
26212 char * kwnames[] = {
26213 (char *) "self",(char *) "needMore", NULL
26214 };
26215
26216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26218 if (!SWIG_IsOK(res1)) {
26219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26220 }
26221 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26222 if (obj1) {
26223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26224 if (!SWIG_IsOK(ecode2)) {
26225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26226 }
26227 arg2 = static_cast< bool >(val2);
26228 }
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 (arg1)->RequestMore(arg2);
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_Py_Void();
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *resultobj = 0;
26244 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26245 bool result;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject *swig_obj[1] ;
26249
26250 if (!args) SWIG_fail;
26251 swig_obj[0] = args;
26252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26255 }
26256 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 {
26264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26265 }
26266 return resultobj;
26267 fail:
26268 return NULL;
26269 }
26270
26271
26272 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26273 PyObject *resultobj = 0;
26274 wxIdleMode arg1 ;
26275 int val1 ;
26276 int ecode1 = 0 ;
26277 PyObject * obj0 = 0 ;
26278 char * kwnames[] = {
26279 (char *) "mode", NULL
26280 };
26281
26282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26283 ecode1 = SWIG_AsVal_int(obj0, &val1);
26284 if (!SWIG_IsOK(ecode1)) {
26285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26286 }
26287 arg1 = static_cast< wxIdleMode >(val1);
26288 {
26289 PyThreadState* __tstate = wxPyBeginAllowThreads();
26290 wxIdleEvent::SetMode(arg1);
26291 wxPyEndAllowThreads(__tstate);
26292 if (PyErr_Occurred()) SWIG_fail;
26293 }
26294 resultobj = SWIG_Py_Void();
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 PyObject *resultobj = 0;
26303 wxIdleMode result;
26304
26305 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = (wxIdleMode)wxIdleEvent::GetMode();
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 resultobj = SWIG_From_int(static_cast< int >(result));
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj = 0;
26321 wxWindow *arg1 = (wxWindow *) 0 ;
26322 bool result;
26323 void *argp1 = 0 ;
26324 int res1 = 0 ;
26325 PyObject * obj0 = 0 ;
26326 char * kwnames[] = {
26327 (char *) "win", NULL
26328 };
26329
26330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26332 if (!SWIG_IsOK(res1)) {
26333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26334 }
26335 arg1 = reinterpret_cast< wxWindow * >(argp1);
26336 {
26337 PyThreadState* __tstate = wxPyBeginAllowThreads();
26338 result = (bool)wxIdleEvent::CanSend(arg1);
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 {
26343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26344 }
26345 return resultobj;
26346 fail:
26347 return NULL;
26348 }
26349
26350
26351 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26352 PyObject *obj;
26353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26354 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26355 return SWIG_Py_Void();
26356 }
26357
26358 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26359 return SWIG_Python_InitShadowInstance(args);
26360 }
26361
26362 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26363 PyObject *resultobj = 0;
26364 int arg1 = (int) 0 ;
26365 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26366 wxPyEvent *result = 0 ;
26367 int val1 ;
26368 int ecode1 = 0 ;
26369 int val2 ;
26370 int ecode2 = 0 ;
26371 PyObject * obj0 = 0 ;
26372 PyObject * obj1 = 0 ;
26373 char * kwnames[] = {
26374 (char *) "winid",(char *) "eventType", NULL
26375 };
26376
26377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26378 if (obj0) {
26379 ecode1 = SWIG_AsVal_int(obj0, &val1);
26380 if (!SWIG_IsOK(ecode1)) {
26381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26382 }
26383 arg1 = static_cast< int >(val1);
26384 }
26385 if (obj1) {
26386 ecode2 = SWIG_AsVal_int(obj1, &val2);
26387 if (!SWIG_IsOK(ecode2)) {
26388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26389 }
26390 arg2 = static_cast< wxEventType >(val2);
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *resultobj = 0;
26407 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26408 void *argp1 = 0 ;
26409 int res1 = 0 ;
26410 PyObject *swig_obj[1] ;
26411
26412 if (!args) SWIG_fail;
26413 swig_obj[0] = args;
26414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26415 if (!SWIG_IsOK(res1)) {
26416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26417 }
26418 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 delete arg1;
26422
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 resultobj = SWIG_Py_Void();
26427 return resultobj;
26428 fail:
26429 return NULL;
26430 }
26431
26432
26433 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26436 PyObject *arg2 = (PyObject *) 0 ;
26437 void *argp1 = 0 ;
26438 int res1 = 0 ;
26439 PyObject * obj0 = 0 ;
26440 PyObject * obj1 = 0 ;
26441 char * kwnames[] = {
26442 (char *) "self",(char *) "self", NULL
26443 };
26444
26445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26447 if (!SWIG_IsOK(res1)) {
26448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26449 }
26450 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26451 arg2 = obj1;
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 (arg1)->SetSelf(arg2);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_Py_Void();
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26466 PyObject *resultobj = 0;
26467 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26468 PyObject *result = 0 ;
26469 void *argp1 = 0 ;
26470 int res1 = 0 ;
26471 PyObject *swig_obj[1] ;
26472
26473 if (!args) SWIG_fail;
26474 swig_obj[0] = args;
26475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26476 if (!SWIG_IsOK(res1)) {
26477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26478 }
26479 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 result = (PyObject *)(arg1)->GetSelf();
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 resultobj = result;
26487 return resultobj;
26488 fail:
26489 return NULL;
26490 }
26491
26492
26493 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26494 PyObject *obj;
26495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26496 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26497 return SWIG_Py_Void();
26498 }
26499
26500 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26501 return SWIG_Python_InitShadowInstance(args);
26502 }
26503
26504 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26505 PyObject *resultobj = 0;
26506 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26507 int arg2 = (int) 0 ;
26508 wxPyCommandEvent *result = 0 ;
26509 int val1 ;
26510 int ecode1 = 0 ;
26511 int val2 ;
26512 int ecode2 = 0 ;
26513 PyObject * obj0 = 0 ;
26514 PyObject * obj1 = 0 ;
26515 char * kwnames[] = {
26516 (char *) "eventType",(char *) "id", NULL
26517 };
26518
26519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26520 if (obj0) {
26521 ecode1 = SWIG_AsVal_int(obj0, &val1);
26522 if (!SWIG_IsOK(ecode1)) {
26523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26524 }
26525 arg1 = static_cast< wxEventType >(val1);
26526 }
26527 if (obj1) {
26528 ecode2 = SWIG_AsVal_int(obj1, &val2);
26529 if (!SWIG_IsOK(ecode2)) {
26530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26531 }
26532 arg2 = static_cast< int >(val2);
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *resultobj = 0;
26549 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26550 void *argp1 = 0 ;
26551 int res1 = 0 ;
26552 PyObject *swig_obj[1] ;
26553
26554 if (!args) SWIG_fail;
26555 swig_obj[0] = args;
26556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26557 if (!SWIG_IsOK(res1)) {
26558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26559 }
26560 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 delete arg1;
26564
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 resultobj = SWIG_Py_Void();
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26578 PyObject *arg2 = (PyObject *) 0 ;
26579 void *argp1 = 0 ;
26580 int res1 = 0 ;
26581 PyObject * obj0 = 0 ;
26582 PyObject * obj1 = 0 ;
26583 char * kwnames[] = {
26584 (char *) "self",(char *) "self", NULL
26585 };
26586
26587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26589 if (!SWIG_IsOK(res1)) {
26590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26591 }
26592 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26593 arg2 = obj1;
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 (arg1)->SetSelf(arg2);
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = SWIG_Py_Void();
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26608 PyObject *resultobj = 0;
26609 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26610 PyObject *result = 0 ;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 PyObject *swig_obj[1] ;
26614
26615 if (!args) SWIG_fail;
26616 swig_obj[0] = args;
26617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26620 }
26621 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 result = (PyObject *)(arg1)->GetSelf();
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 resultobj = result;
26629 return resultobj;
26630 fail:
26631 return NULL;
26632 }
26633
26634
26635 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26636 PyObject *obj;
26637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26638 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26639 return SWIG_Py_Void();
26640 }
26641
26642 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26643 return SWIG_Python_InitShadowInstance(args);
26644 }
26645
26646 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj = 0;
26648 wxWindow *arg1 = (wxWindow *) 0 ;
26649 wxDateTime *arg2 = 0 ;
26650 wxEventType arg3 ;
26651 wxDateEvent *result = 0 ;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 void *argp2 = 0 ;
26655 int res2 = 0 ;
26656 int val3 ;
26657 int ecode3 = 0 ;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 PyObject * obj2 = 0 ;
26661 char * kwnames[] = {
26662 (char *) "win",(char *) "dt",(char *) "type", NULL
26663 };
26664
26665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26667 if (!SWIG_IsOK(res1)) {
26668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26669 }
26670 arg1 = reinterpret_cast< wxWindow * >(argp1);
26671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26672 if (!SWIG_IsOK(res2)) {
26673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26674 }
26675 if (!argp2) {
26676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26677 }
26678 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26679 ecode3 = SWIG_AsVal_int(obj2, &val3);
26680 if (!SWIG_IsOK(ecode3)) {
26681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26682 }
26683 arg3 = static_cast< wxEventType >(val3);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26698 PyObject *resultobj = 0;
26699 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26700 wxDateTime *result = 0 ;
26701 void *argp1 = 0 ;
26702 int res1 = 0 ;
26703 PyObject *swig_obj[1] ;
26704
26705 if (!args) SWIG_fail;
26706 swig_obj[0] = args;
26707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26708 if (!SWIG_IsOK(res1)) {
26709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26710 }
26711 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26712 {
26713 PyThreadState* __tstate = wxPyBeginAllowThreads();
26714 {
26715 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26716 result = (wxDateTime *) &_result_ref;
26717 }
26718 wxPyEndAllowThreads(__tstate);
26719 if (PyErr_Occurred()) SWIG_fail;
26720 }
26721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26729 PyObject *resultobj = 0;
26730 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26731 wxDateTime *arg2 = 0 ;
26732 void *argp1 = 0 ;
26733 int res1 = 0 ;
26734 void *argp2 = 0 ;
26735 int res2 = 0 ;
26736 PyObject * obj0 = 0 ;
26737 PyObject * obj1 = 0 ;
26738 char * kwnames[] = {
26739 (char *) "self",(char *) "date", NULL
26740 };
26741
26742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26744 if (!SWIG_IsOK(res1)) {
26745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26746 }
26747 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26748 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26749 if (!SWIG_IsOK(res2)) {
26750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26751 }
26752 if (!argp2) {
26753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26754 }
26755 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->SetDate((wxDateTime const &)*arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_Py_Void();
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *obj;
26771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26772 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26773 return SWIG_Py_Void();
26774 }
26775
26776 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26777 return SWIG_Python_InitShadowInstance(args);
26778 }
26779
26780 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26781 PyObject *resultobj = 0;
26782 wxPyApp *result = 0 ;
26783
26784 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (wxPyApp *)new_wxPyApp();
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *resultobj = 0;
26800 wxPyApp *arg1 = (wxPyApp *) 0 ;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 PyObject *swig_obj[1] ;
26804
26805 if (!args) SWIG_fail;
26806 swig_obj[0] = args;
26807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26808 if (!SWIG_IsOK(res1)) {
26809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26810 }
26811 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 delete arg1;
26815
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 resultobj = SWIG_Py_Void();
26820 return resultobj;
26821 fail:
26822 return NULL;
26823 }
26824
26825
26826 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26827 PyObject *resultobj = 0;
26828 wxPyApp *arg1 = (wxPyApp *) 0 ;
26829 PyObject *arg2 = (PyObject *) 0 ;
26830 PyObject *arg3 = (PyObject *) 0 ;
26831 bool arg4 ;
26832 void *argp1 = 0 ;
26833 int res1 = 0 ;
26834 bool val4 ;
26835 int ecode4 = 0 ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 PyObject * obj2 = 0 ;
26839 PyObject * obj3 = 0 ;
26840 char * kwnames[] = {
26841 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26842 };
26843
26844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26846 if (!SWIG_IsOK(res1)) {
26847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26848 }
26849 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26850 arg2 = obj1;
26851 arg3 = obj2;
26852 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26853 if (!SWIG_IsOK(ecode4)) {
26854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26855 }
26856 arg4 = static_cast< bool >(val4);
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 resultobj = SWIG_Py_Void();
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26871 PyObject *resultobj = 0;
26872 wxPyApp *arg1 = (wxPyApp *) 0 ;
26873 wxString result;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 PyObject *swig_obj[1] ;
26877
26878 if (!args) SWIG_fail;
26879 swig_obj[0] = args;
26880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26881 if (!SWIG_IsOK(res1)) {
26882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26883 }
26884 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = ((wxPyApp const *)arg1)->GetAppName();
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 {
26892 #if wxUSE_UNICODE
26893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26894 #else
26895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26896 #endif
26897 }
26898 return resultobj;
26899 fail:
26900 return NULL;
26901 }
26902
26903
26904 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26905 PyObject *resultobj = 0;
26906 wxPyApp *arg1 = (wxPyApp *) 0 ;
26907 wxString *arg2 = 0 ;
26908 void *argp1 = 0 ;
26909 int res1 = 0 ;
26910 bool temp2 = false ;
26911 PyObject * obj0 = 0 ;
26912 PyObject * obj1 = 0 ;
26913 char * kwnames[] = {
26914 (char *) "self",(char *) "name", NULL
26915 };
26916
26917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26921 }
26922 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26923 {
26924 arg2 = wxString_in_helper(obj1);
26925 if (arg2 == NULL) SWIG_fail;
26926 temp2 = true;
26927 }
26928 {
26929 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 (arg1)->SetAppName((wxString const &)*arg2);
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_Py_Void();
26935 {
26936 if (temp2)
26937 delete arg2;
26938 }
26939 return resultobj;
26940 fail:
26941 {
26942 if (temp2)
26943 delete arg2;
26944 }
26945 return NULL;
26946 }
26947
26948
26949 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26950 PyObject *resultobj = 0;
26951 wxPyApp *arg1 = (wxPyApp *) 0 ;
26952 wxString result;
26953 void *argp1 = 0 ;
26954 int res1 = 0 ;
26955 PyObject *swig_obj[1] ;
26956
26957 if (!args) SWIG_fail;
26958 swig_obj[0] = args;
26959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26960 if (!SWIG_IsOK(res1)) {
26961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26962 }
26963 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 result = ((wxPyApp const *)arg1)->GetClassName();
26967 wxPyEndAllowThreads(__tstate);
26968 if (PyErr_Occurred()) SWIG_fail;
26969 }
26970 {
26971 #if wxUSE_UNICODE
26972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26973 #else
26974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26975 #endif
26976 }
26977 return resultobj;
26978 fail:
26979 return NULL;
26980 }
26981
26982
26983 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26984 PyObject *resultobj = 0;
26985 wxPyApp *arg1 = (wxPyApp *) 0 ;
26986 wxString *arg2 = 0 ;
26987 void *argp1 = 0 ;
26988 int res1 = 0 ;
26989 bool temp2 = false ;
26990 PyObject * obj0 = 0 ;
26991 PyObject * obj1 = 0 ;
26992 char * kwnames[] = {
26993 (char *) "self",(char *) "name", NULL
26994 };
26995
26996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26998 if (!SWIG_IsOK(res1)) {
26999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27000 }
27001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27002 {
27003 arg2 = wxString_in_helper(obj1);
27004 if (arg2 == NULL) SWIG_fail;
27005 temp2 = true;
27006 }
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 (arg1)->SetClassName((wxString const &)*arg2);
27010 wxPyEndAllowThreads(__tstate);
27011 if (PyErr_Occurred()) SWIG_fail;
27012 }
27013 resultobj = SWIG_Py_Void();
27014 {
27015 if (temp2)
27016 delete arg2;
27017 }
27018 return resultobj;
27019 fail:
27020 {
27021 if (temp2)
27022 delete arg2;
27023 }
27024 return NULL;
27025 }
27026
27027
27028 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27029 PyObject *resultobj = 0;
27030 wxPyApp *arg1 = (wxPyApp *) 0 ;
27031 wxString *result = 0 ;
27032 void *argp1 = 0 ;
27033 int res1 = 0 ;
27034 PyObject *swig_obj[1] ;
27035
27036 if (!args) SWIG_fail;
27037 swig_obj[0] = args;
27038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27039 if (!SWIG_IsOK(res1)) {
27040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27041 }
27042 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27043 {
27044 PyThreadState* __tstate = wxPyBeginAllowThreads();
27045 {
27046 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27047 result = (wxString *) &_result_ref;
27048 }
27049 wxPyEndAllowThreads(__tstate);
27050 if (PyErr_Occurred()) SWIG_fail;
27051 }
27052 {
27053 #if wxUSE_UNICODE
27054 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27055 #else
27056 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27057 #endif
27058 }
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj = 0;
27067 wxPyApp *arg1 = (wxPyApp *) 0 ;
27068 wxString *arg2 = 0 ;
27069 void *argp1 = 0 ;
27070 int res1 = 0 ;
27071 bool temp2 = false ;
27072 PyObject * obj0 = 0 ;
27073 PyObject * obj1 = 0 ;
27074 char * kwnames[] = {
27075 (char *) "self",(char *) "name", NULL
27076 };
27077
27078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27080 if (!SWIG_IsOK(res1)) {
27081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27082 }
27083 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27084 {
27085 arg2 = wxString_in_helper(obj1);
27086 if (arg2 == NULL) SWIG_fail;
27087 temp2 = true;
27088 }
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 (arg1)->SetVendorName((wxString const &)*arg2);
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 resultobj = SWIG_Py_Void();
27096 {
27097 if (temp2)
27098 delete arg2;
27099 }
27100 return resultobj;
27101 fail:
27102 {
27103 if (temp2)
27104 delete arg2;
27105 }
27106 return NULL;
27107 }
27108
27109
27110 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27111 PyObject *resultobj = 0;
27112 wxPyApp *arg1 = (wxPyApp *) 0 ;
27113 wxAppTraits *result = 0 ;
27114 void *argp1 = 0 ;
27115 int res1 = 0 ;
27116 PyObject *swig_obj[1] ;
27117
27118 if (!args) SWIG_fail;
27119 swig_obj[0] = args;
27120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27121 if (!SWIG_IsOK(res1)) {
27122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27123 }
27124 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27125 {
27126 PyThreadState* __tstate = wxPyBeginAllowThreads();
27127 result = (wxAppTraits *)(arg1)->GetTraits();
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27139 PyObject *resultobj = 0;
27140 wxPyApp *arg1 = (wxPyApp *) 0 ;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 PyObject *swig_obj[1] ;
27144
27145 if (!args) SWIG_fail;
27146 swig_obj[0] = args;
27147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27148 if (!SWIG_IsOK(res1)) {
27149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27150 }
27151 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 (arg1)->ProcessPendingEvents();
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 resultobj = SWIG_Py_Void();
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27166 PyObject *resultobj = 0;
27167 wxPyApp *arg1 = (wxPyApp *) 0 ;
27168 bool arg2 = (bool) false ;
27169 bool result;
27170 void *argp1 = 0 ;
27171 int res1 = 0 ;
27172 bool val2 ;
27173 int ecode2 = 0 ;
27174 PyObject * obj0 = 0 ;
27175 PyObject * obj1 = 0 ;
27176 char * kwnames[] = {
27177 (char *) "self",(char *) "onlyIfNeeded", NULL
27178 };
27179
27180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27182 if (!SWIG_IsOK(res1)) {
27183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27184 }
27185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27186 if (obj1) {
27187 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27188 if (!SWIG_IsOK(ecode2)) {
27189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27190 }
27191 arg2 = static_cast< bool >(val2);
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (bool)(arg1)->Yield(arg2);
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27209 PyObject *resultobj = 0;
27210 wxPyApp *arg1 = (wxPyApp *) 0 ;
27211 void *argp1 = 0 ;
27212 int res1 = 0 ;
27213 PyObject *swig_obj[1] ;
27214
27215 if (!args) SWIG_fail;
27216 swig_obj[0] = args;
27217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27218 if (!SWIG_IsOK(res1)) {
27219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27220 }
27221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->WakeUpIdle();
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 resultobj = SWIG_Py_Void();
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27236 PyObject *resultobj = 0;
27237 bool result;
27238
27239 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (bool)wxPyApp::IsMainLoopRunning();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27256 PyObject *resultobj = 0;
27257 wxPyApp *arg1 = (wxPyApp *) 0 ;
27258 int result;
27259 void *argp1 = 0 ;
27260 int res1 = 0 ;
27261 PyObject *swig_obj[1] ;
27262
27263 if (!args) SWIG_fail;
27264 swig_obj[0] = args;
27265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27266 if (!SWIG_IsOK(res1)) {
27267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27268 }
27269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = (int)(arg1)->MainLoop();
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = SWIG_From_int(static_cast< int >(result));
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27284 PyObject *resultobj = 0;
27285 wxPyApp *arg1 = (wxPyApp *) 0 ;
27286 void *argp1 = 0 ;
27287 int res1 = 0 ;
27288 PyObject *swig_obj[1] ;
27289
27290 if (!args) SWIG_fail;
27291 swig_obj[0] = args;
27292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27293 if (!SWIG_IsOK(res1)) {
27294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27295 }
27296 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 (arg1)->Exit();
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 resultobj = SWIG_Py_Void();
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27311 PyObject *resultobj = 0;
27312 wxPyApp *arg1 = (wxPyApp *) 0 ;
27313 void *argp1 = 0 ;
27314 int res1 = 0 ;
27315 PyObject *swig_obj[1] ;
27316
27317 if (!args) SWIG_fail;
27318 swig_obj[0] = args;
27319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27320 if (!SWIG_IsOK(res1)) {
27321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27322 }
27323 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27324 {
27325 PyThreadState* __tstate = wxPyBeginAllowThreads();
27326 (arg1)->ExitMainLoop();
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 resultobj = SWIG_Py_Void();
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27338 PyObject *resultobj = 0;
27339 wxPyApp *arg1 = (wxPyApp *) 0 ;
27340 bool result;
27341 void *argp1 = 0 ;
27342 int res1 = 0 ;
27343 PyObject *swig_obj[1] ;
27344
27345 if (!args) SWIG_fail;
27346 swig_obj[0] = args;
27347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27348 if (!SWIG_IsOK(res1)) {
27349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27350 }
27351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (bool)(arg1)->Pending();
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 {
27359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 PyObject *resultobj = 0;
27369 wxPyApp *arg1 = (wxPyApp *) 0 ;
27370 bool result;
27371 void *argp1 = 0 ;
27372 int res1 = 0 ;
27373 PyObject *swig_obj[1] ;
27374
27375 if (!args) SWIG_fail;
27376 swig_obj[0] = args;
27377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27378 if (!SWIG_IsOK(res1)) {
27379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27380 }
27381 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27382 {
27383 PyThreadState* __tstate = wxPyBeginAllowThreads();
27384 result = (bool)(arg1)->Dispatch();
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 {
27389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27390 }
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27398 PyObject *resultobj = 0;
27399 wxPyApp *arg1 = (wxPyApp *) 0 ;
27400 bool result;
27401 void *argp1 = 0 ;
27402 int res1 = 0 ;
27403 PyObject *swig_obj[1] ;
27404
27405 if (!args) SWIG_fail;
27406 swig_obj[0] = args;
27407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27408 if (!SWIG_IsOK(res1)) {
27409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27410 }
27411 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 result = (bool)(arg1)->ProcessIdle();
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 {
27419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27420 }
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27428 PyObject *resultobj = 0;
27429 wxPyApp *arg1 = (wxPyApp *) 0 ;
27430 wxWindow *arg2 = (wxWindow *) 0 ;
27431 wxIdleEvent *arg3 = 0 ;
27432 bool result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 void *argp2 = 0 ;
27436 int res2 = 0 ;
27437 void *argp3 = 0 ;
27438 int res3 = 0 ;
27439 PyObject * obj0 = 0 ;
27440 PyObject * obj1 = 0 ;
27441 PyObject * obj2 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "win",(char *) "event", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27453 if (!SWIG_IsOK(res2)) {
27454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27455 }
27456 arg2 = reinterpret_cast< wxWindow * >(argp2);
27457 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27458 if (!SWIG_IsOK(res3)) {
27459 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27460 }
27461 if (!argp3) {
27462 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27463 }
27464 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 {
27472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27473 }
27474 return resultobj;
27475 fail:
27476 return NULL;
27477 }
27478
27479
27480 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27481 PyObject *resultobj = 0;
27482 wxPyApp *arg1 = (wxPyApp *) 0 ;
27483 bool result;
27484 void *argp1 = 0 ;
27485 int res1 = 0 ;
27486 PyObject *swig_obj[1] ;
27487
27488 if (!args) SWIG_fail;
27489 swig_obj[0] = args;
27490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27491 if (!SWIG_IsOK(res1)) {
27492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27493 }
27494 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 result = (bool)((wxPyApp const *)arg1)->IsActive();
27498 wxPyEndAllowThreads(__tstate);
27499 if (PyErr_Occurred()) SWIG_fail;
27500 }
27501 {
27502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27503 }
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27511 PyObject *resultobj = 0;
27512 wxPyApp *arg1 = (wxPyApp *) 0 ;
27513 wxWindow *arg2 = (wxWindow *) 0 ;
27514 void *argp1 = 0 ;
27515 int res1 = 0 ;
27516 void *argp2 = 0 ;
27517 int res2 = 0 ;
27518 PyObject * obj0 = 0 ;
27519 PyObject * obj1 = 0 ;
27520 char * kwnames[] = {
27521 (char *) "self",(char *) "win", NULL
27522 };
27523
27524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27526 if (!SWIG_IsOK(res1)) {
27527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27528 }
27529 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27531 if (!SWIG_IsOK(res2)) {
27532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27533 }
27534 arg2 = reinterpret_cast< wxWindow * >(argp2);
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 (arg1)->SetTopWindow(arg2);
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = SWIG_Py_Void();
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27549 PyObject *resultobj = 0;
27550 wxPyApp *arg1 = (wxPyApp *) 0 ;
27551 wxWindow *result = 0 ;
27552 void *argp1 = 0 ;
27553 int res1 = 0 ;
27554 PyObject *swig_obj[1] ;
27555
27556 if (!args) SWIG_fail;
27557 swig_obj[0] = args;
27558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27559 if (!SWIG_IsOK(res1)) {
27560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27561 }
27562 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 {
27570 resultobj = wxPyMake_wxObject(result, (bool)0);
27571 }
27572 return resultobj;
27573 fail:
27574 return NULL;
27575 }
27576
27577
27578 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj = 0;
27580 wxPyApp *arg1 = (wxPyApp *) 0 ;
27581 bool arg2 ;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 bool val2 ;
27585 int ecode2 = 0 ;
27586 PyObject * obj0 = 0 ;
27587 PyObject * obj1 = 0 ;
27588 char * kwnames[] = {
27589 (char *) "self",(char *) "flag", NULL
27590 };
27591
27592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27596 }
27597 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27599 if (!SWIG_IsOK(ecode2)) {
27600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27601 }
27602 arg2 = static_cast< bool >(val2);
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 (arg1)->SetExitOnFrameDelete(arg2);
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 resultobj = SWIG_Py_Void();
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27617 PyObject *resultobj = 0;
27618 wxPyApp *arg1 = (wxPyApp *) 0 ;
27619 bool result;
27620 void *argp1 = 0 ;
27621 int res1 = 0 ;
27622 PyObject *swig_obj[1] ;
27623
27624 if (!args) SWIG_fail;
27625 swig_obj[0] = args;
27626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27627 if (!SWIG_IsOK(res1)) {
27628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27629 }
27630 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 {
27638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27639 }
27640 return resultobj;
27641 fail:
27642 return NULL;
27643 }
27644
27645
27646 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27647 PyObject *resultobj = 0;
27648 wxPyApp *arg1 = (wxPyApp *) 0 ;
27649 bool arg2 ;
27650 void *argp1 = 0 ;
27651 int res1 = 0 ;
27652 bool val2 ;
27653 int ecode2 = 0 ;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 char * kwnames[] = {
27657 (char *) "self",(char *) "flag", NULL
27658 };
27659
27660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27662 if (!SWIG_IsOK(res1)) {
27663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27664 }
27665 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27666 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27667 if (!SWIG_IsOK(ecode2)) {
27668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27669 }
27670 arg2 = static_cast< bool >(val2);
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 (arg1)->SetUseBestVisual(arg2);
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 resultobj = SWIG_Py_Void();
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27685 PyObject *resultobj = 0;
27686 wxPyApp *arg1 = (wxPyApp *) 0 ;
27687 bool result;
27688 void *argp1 = 0 ;
27689 int res1 = 0 ;
27690 PyObject *swig_obj[1] ;
27691
27692 if (!args) SWIG_fail;
27693 swig_obj[0] = args;
27694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27695 if (!SWIG_IsOK(res1)) {
27696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27697 }
27698 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27699 {
27700 PyThreadState* __tstate = wxPyBeginAllowThreads();
27701 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 {
27706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27707 }
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27715 PyObject *resultobj = 0;
27716 wxPyApp *arg1 = (wxPyApp *) 0 ;
27717 int arg2 ;
27718 void *argp1 = 0 ;
27719 int res1 = 0 ;
27720 int val2 ;
27721 int ecode2 = 0 ;
27722 PyObject * obj0 = 0 ;
27723 PyObject * obj1 = 0 ;
27724 char * kwnames[] = {
27725 (char *) "self",(char *) "mode", NULL
27726 };
27727
27728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27730 if (!SWIG_IsOK(res1)) {
27731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27732 }
27733 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27734 ecode2 = SWIG_AsVal_int(obj1, &val2);
27735 if (!SWIG_IsOK(ecode2)) {
27736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27737 }
27738 arg2 = static_cast< int >(val2);
27739 {
27740 PyThreadState* __tstate = wxPyBeginAllowThreads();
27741 (arg1)->SetPrintMode(arg2);
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 resultobj = SWIG_Py_Void();
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27753 PyObject *resultobj = 0;
27754 wxPyApp *arg1 = (wxPyApp *) 0 ;
27755 int result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 PyObject *swig_obj[1] ;
27759
27760 if (!args) SWIG_fail;
27761 swig_obj[0] = args;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27765 }
27766 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 resultobj = SWIG_From_int(static_cast< int >(result));
27774 return resultobj;
27775 fail:
27776 return NULL;
27777 }
27778
27779
27780 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27781 PyObject *resultobj = 0;
27782 wxPyApp *arg1 = (wxPyApp *) 0 ;
27783 int arg2 ;
27784 void *argp1 = 0 ;
27785 int res1 = 0 ;
27786 int val2 ;
27787 int ecode2 = 0 ;
27788 PyObject * obj0 = 0 ;
27789 PyObject * obj1 = 0 ;
27790 char * kwnames[] = {
27791 (char *) "self",(char *) "mode", NULL
27792 };
27793
27794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27796 if (!SWIG_IsOK(res1)) {
27797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27798 }
27799 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27800 ecode2 = SWIG_AsVal_int(obj1, &val2);
27801 if (!SWIG_IsOK(ecode2)) {
27802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27803 }
27804 arg2 = static_cast< int >(val2);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 (arg1)->SetAssertMode(arg2);
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 resultobj = SWIG_Py_Void();
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27819 PyObject *resultobj = 0;
27820 wxPyApp *arg1 = (wxPyApp *) 0 ;
27821 int result;
27822 void *argp1 = 0 ;
27823 int res1 = 0 ;
27824 PyObject *swig_obj[1] ;
27825
27826 if (!args) SWIG_fail;
27827 swig_obj[0] = args;
27828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27829 if (!SWIG_IsOK(res1)) {
27830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27831 }
27832 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = (int)(arg1)->GetAssertMode();
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 resultobj = SWIG_From_int(static_cast< int >(result));
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27847 PyObject *resultobj = 0;
27848 bool result;
27849
27850 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 {
27858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27859 }
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 long result;
27869
27870 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 result = (long)wxPyApp::GetMacAboutMenuItemId();
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 resultobj = SWIG_From_long(static_cast< long >(result));
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27885 PyObject *resultobj = 0;
27886 long result;
27887
27888 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 resultobj = SWIG_From_long(static_cast< long >(result));
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27903 PyObject *resultobj = 0;
27904 long result;
27905
27906 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (long)wxPyApp::GetMacExitMenuItemId();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 resultobj = SWIG_From_long(static_cast< long >(result));
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27921 PyObject *resultobj = 0;
27922 wxString result;
27923
27924 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 result = wxPyApp::GetMacHelpMenuTitleName();
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 {
27932 #if wxUSE_UNICODE
27933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27934 #else
27935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27936 #endif
27937 }
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = 0;
27946 bool arg1 ;
27947 bool val1 ;
27948 int ecode1 = 0 ;
27949 PyObject * obj0 = 0 ;
27950 char * kwnames[] = {
27951 (char *) "val", NULL
27952 };
27953
27954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27955 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27956 if (!SWIG_IsOK(ecode1)) {
27957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27958 }
27959 arg1 = static_cast< bool >(val1);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 resultobj = SWIG_Py_Void();
27967 return resultobj;
27968 fail:
27969 return NULL;
27970 }
27971
27972
27973 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27974 PyObject *resultobj = 0;
27975 long arg1 ;
27976 long val1 ;
27977 int ecode1 = 0 ;
27978 PyObject * obj0 = 0 ;
27979 char * kwnames[] = {
27980 (char *) "val", NULL
27981 };
27982
27983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27984 ecode1 = SWIG_AsVal_long(obj0, &val1);
27985 if (!SWIG_IsOK(ecode1)) {
27986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27987 }
27988 arg1 = static_cast< long >(val1);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 wxPyApp::SetMacAboutMenuItemId(arg1);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 resultobj = SWIG_Py_Void();
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj = 0;
28004 long arg1 ;
28005 long val1 ;
28006 int ecode1 = 0 ;
28007 PyObject * obj0 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "val", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28013 ecode1 = SWIG_AsVal_long(obj0, &val1);
28014 if (!SWIG_IsOK(ecode1)) {
28015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28016 }
28017 arg1 = static_cast< long >(val1);
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_Py_Void();
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 long arg1 ;
28034 long val1 ;
28035 int ecode1 = 0 ;
28036 PyObject * obj0 = 0 ;
28037 char * kwnames[] = {
28038 (char *) "val", NULL
28039 };
28040
28041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28042 ecode1 = SWIG_AsVal_long(obj0, &val1);
28043 if (!SWIG_IsOK(ecode1)) {
28044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28045 }
28046 arg1 = static_cast< long >(val1);
28047 {
28048 PyThreadState* __tstate = wxPyBeginAllowThreads();
28049 wxPyApp::SetMacExitMenuItemId(arg1);
28050 wxPyEndAllowThreads(__tstate);
28051 if (PyErr_Occurred()) SWIG_fail;
28052 }
28053 resultobj = SWIG_Py_Void();
28054 return resultobj;
28055 fail:
28056 return NULL;
28057 }
28058
28059
28060 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28061 PyObject *resultobj = 0;
28062 wxString *arg1 = 0 ;
28063 bool temp1 = false ;
28064 PyObject * obj0 = 0 ;
28065 char * kwnames[] = {
28066 (char *) "val", NULL
28067 };
28068
28069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28070 {
28071 arg1 = wxString_in_helper(obj0);
28072 if (arg1 == NULL) SWIG_fail;
28073 temp1 = true;
28074 }
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 resultobj = SWIG_Py_Void();
28082 {
28083 if (temp1)
28084 delete arg1;
28085 }
28086 return resultobj;
28087 fail:
28088 {
28089 if (temp1)
28090 delete arg1;
28091 }
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28097 PyObject *resultobj = 0;
28098 wxPyApp *arg1 = (wxPyApp *) 0 ;
28099 void *argp1 = 0 ;
28100 int res1 = 0 ;
28101 PyObject *swig_obj[1] ;
28102
28103 if (!args) SWIG_fail;
28104 swig_obj[0] = args;
28105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28106 if (!SWIG_IsOK(res1)) {
28107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28108 }
28109 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 (arg1)->_BootstrapApp();
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_Py_Void();
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28124 PyObject *resultobj = 0;
28125 int result;
28126
28127 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 result = (int)wxPyApp::GetComCtl32Version();
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 resultobj = SWIG_From_int(static_cast< int >(result));
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28142 PyObject *obj;
28143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28144 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28145 return SWIG_Py_Void();
28146 }
28147
28148 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28149 return SWIG_Python_InitShadowInstance(args);
28150 }
28151
28152 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28153 PyObject *resultobj = 0;
28154
28155 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 wxExit();
28159 wxPyEndAllowThreads(__tstate);
28160 if (PyErr_Occurred()) SWIG_fail;
28161 }
28162 resultobj = SWIG_Py_Void();
28163 return resultobj;
28164 fail:
28165 return NULL;
28166 }
28167
28168
28169 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28170 PyObject *resultobj = 0;
28171 bool result;
28172
28173 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (bool)wxYield();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 {
28181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28190 PyObject *resultobj = 0;
28191 bool result;
28192
28193 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 result = (bool)wxYieldIfNeeded();
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 {
28201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28202 }
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj = 0;
28211 wxWindow *arg1 = (wxWindow *) NULL ;
28212 bool arg2 = (bool) false ;
28213 bool result;
28214 void *argp1 = 0 ;
28215 int res1 = 0 ;
28216 bool val2 ;
28217 int ecode2 = 0 ;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char * kwnames[] = {
28221 (char *) "win",(char *) "onlyIfNeeded", NULL
28222 };
28223
28224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28225 if (obj0) {
28226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28227 if (!SWIG_IsOK(res1)) {
28228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28229 }
28230 arg1 = reinterpret_cast< wxWindow * >(argp1);
28231 }
28232 if (obj1) {
28233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28234 if (!SWIG_IsOK(ecode2)) {
28235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28236 }
28237 arg2 = static_cast< bool >(val2);
28238 }
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (bool)wxSafeYield(arg1,arg2);
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28255 PyObject *resultobj = 0;
28256
28257 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 wxWakeUpIdle();
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 resultobj = SWIG_Py_Void();
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj = 0;
28273 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28274 wxEvent *arg2 = 0 ;
28275 void *argp1 = 0 ;
28276 int res1 = 0 ;
28277 void *argp2 = 0 ;
28278 int res2 = 0 ;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "dest",(char *) "event", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28287 if (!SWIG_IsOK(res1)) {
28288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28289 }
28290 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28292 if (!SWIG_IsOK(res2)) {
28293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28294 }
28295 if (!argp2) {
28296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28297 }
28298 arg2 = reinterpret_cast< wxEvent * >(argp2);
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 wxPostEvent(arg1,*arg2);
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 resultobj = SWIG_Py_Void();
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28313 PyObject *resultobj = 0;
28314
28315 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 wxApp_CleanUp();
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 resultobj = SWIG_Py_Void();
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 PyObject *resultobj = 0;
28331 wxPyApp *result = 0 ;
28332
28333 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = (wxPyApp *)wxPyGetApp();
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 {
28341 resultobj = wxPyMake_wxObject(result, 0);
28342 }
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28350 PyObject *resultobj = 0;
28351 char *arg1 = (char *) 0 ;
28352 int res1 ;
28353 char *buf1 = 0 ;
28354 int alloc1 = 0 ;
28355 PyObject * obj0 = 0 ;
28356 char * kwnames[] = {
28357 (char *) "encoding", NULL
28358 };
28359
28360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28361 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28362 if (!SWIG_IsOK(res1)) {
28363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28364 }
28365 arg1 = buf1;
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 wxSetDefaultPyEncoding((char const *)arg1);
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_Py_Void();
28373 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28374 return resultobj;
28375 fail:
28376 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28377 return NULL;
28378 }
28379
28380
28381 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28382 PyObject *resultobj = 0;
28383 char *result = 0 ;
28384
28385 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (char *)wxGetDefaultPyEncoding();
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 resultobj = SWIG_FromCharPtr(result);
28393 return resultobj;
28394 fail:
28395 return NULL;
28396 }
28397
28398
28399 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28400 PyObject *resultobj = 0;
28401 wxEventLoop *result = 0 ;
28402
28403 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 result = (wxEventLoop *)new wxEventLoop();
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28420 void *argp1 = 0 ;
28421 int res1 = 0 ;
28422 PyObject *swig_obj[1] ;
28423
28424 if (!args) SWIG_fail;
28425 swig_obj[0] = args;
28426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28427 if (!SWIG_IsOK(res1)) {
28428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28429 }
28430 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 delete arg1;
28434
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 resultobj = SWIG_Py_Void();
28439 return resultobj;
28440 fail:
28441 return NULL;
28442 }
28443
28444
28445 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28446 PyObject *resultobj = 0;
28447 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28448 int result;
28449 void *argp1 = 0 ;
28450 int res1 = 0 ;
28451 PyObject *swig_obj[1] ;
28452
28453 if (!args) SWIG_fail;
28454 swig_obj[0] = args;
28455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28456 if (!SWIG_IsOK(res1)) {
28457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28458 }
28459 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (int)(arg1)->Run();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 resultobj = SWIG_From_int(static_cast< int >(result));
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj = 0;
28475 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28476 int arg2 = (int) 0 ;
28477 void *argp1 = 0 ;
28478 int res1 = 0 ;
28479 int val2 ;
28480 int ecode2 = 0 ;
28481 PyObject * obj0 = 0 ;
28482 PyObject * obj1 = 0 ;
28483 char * kwnames[] = {
28484 (char *) "self",(char *) "rc", NULL
28485 };
28486
28487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28489 if (!SWIG_IsOK(res1)) {
28490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28491 }
28492 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28493 if (obj1) {
28494 ecode2 = SWIG_AsVal_int(obj1, &val2);
28495 if (!SWIG_IsOK(ecode2)) {
28496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28497 }
28498 arg2 = static_cast< int >(val2);
28499 }
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 (arg1)->Exit(arg2);
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 resultobj = SWIG_Py_Void();
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28514 PyObject *resultobj = 0;
28515 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28516 bool result;
28517 void *argp1 = 0 ;
28518 int res1 = 0 ;
28519 PyObject *swig_obj[1] ;
28520
28521 if (!args) SWIG_fail;
28522 swig_obj[0] = args;
28523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28524 if (!SWIG_IsOK(res1)) {
28525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28526 }
28527 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (bool)((wxEventLoop const *)arg1)->Pending();
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 {
28535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *resultobj = 0;
28545 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28546 bool result;
28547 void *argp1 = 0 ;
28548 int res1 = 0 ;
28549 PyObject *swig_obj[1] ;
28550
28551 if (!args) SWIG_fail;
28552 swig_obj[0] = args;
28553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28554 if (!SWIG_IsOK(res1)) {
28555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28556 }
28557 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (bool)(arg1)->Dispatch();
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 {
28565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28566 }
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28576 bool result;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 PyObject *swig_obj[1] ;
28580
28581 if (!args) SWIG_fail;
28582 swig_obj[0] = args;
28583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28586 }
28587 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28604 PyObject *resultobj = 0;
28605 wxEventLoop *result = 0 ;
28606
28607 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 result = (wxEventLoop *)wxEventLoop::GetActive();
28611 wxPyEndAllowThreads(__tstate);
28612 if (PyErr_Occurred()) SWIG_fail;
28613 }
28614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28615 return resultobj;
28616 fail:
28617 return NULL;
28618 }
28619
28620
28621 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28622 PyObject *resultobj = 0;
28623 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28624 void *argp1 = 0 ;
28625 int res1 = 0 ;
28626 PyObject * obj0 = 0 ;
28627 char * kwnames[] = {
28628 (char *) "loop", NULL
28629 };
28630
28631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28633 if (!SWIG_IsOK(res1)) {
28634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28635 }
28636 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 wxEventLoop::SetActive(arg1);
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 resultobj = SWIG_Py_Void();
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28651 PyObject *obj;
28652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28653 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28654 return SWIG_Py_Void();
28655 }
28656
28657 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28658 return SWIG_Python_InitShadowInstance(args);
28659 }
28660
28661 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = 0;
28663 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28664 wxEventLoopActivator *result = 0 ;
28665 void *argp1 = 0 ;
28666 int res1 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 char * kwnames[] = {
28669 (char *) "evtLoop", NULL
28670 };
28671
28672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28674 if (!SWIG_IsOK(res1)) {
28675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28676 }
28677 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28692 PyObject *resultobj = 0;
28693 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28694 void *argp1 = 0 ;
28695 int res1 = 0 ;
28696 PyObject *swig_obj[1] ;
28697
28698 if (!args) SWIG_fail;
28699 swig_obj[0] = args;
28700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28701 if (!SWIG_IsOK(res1)) {
28702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28703 }
28704 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 delete arg1;
28708
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_Py_Void();
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28720 PyObject *obj;
28721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28722 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28723 return SWIG_Py_Void();
28724 }
28725
28726 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28727 return SWIG_Python_InitShadowInstance(args);
28728 }
28729
28730 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj = 0;
28732 int arg1 = (int) 0 ;
28733 int arg2 = (int) 0 ;
28734 int arg3 = (int) 0 ;
28735 wxAcceleratorEntry *result = 0 ;
28736 int val1 ;
28737 int ecode1 = 0 ;
28738 int val2 ;
28739 int ecode2 = 0 ;
28740 int val3 ;
28741 int ecode3 = 0 ;
28742 PyObject * obj0 = 0 ;
28743 PyObject * obj1 = 0 ;
28744 PyObject * obj2 = 0 ;
28745 char * kwnames[] = {
28746 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28747 };
28748
28749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28750 if (obj0) {
28751 ecode1 = SWIG_AsVal_int(obj0, &val1);
28752 if (!SWIG_IsOK(ecode1)) {
28753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28754 }
28755 arg1 = static_cast< int >(val1);
28756 }
28757 if (obj1) {
28758 ecode2 = SWIG_AsVal_int(obj1, &val2);
28759 if (!SWIG_IsOK(ecode2)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28761 }
28762 arg2 = static_cast< int >(val2);
28763 }
28764 if (obj2) {
28765 ecode3 = SWIG_AsVal_int(obj2, &val3);
28766 if (!SWIG_IsOK(ecode3)) {
28767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28768 }
28769 arg3 = static_cast< int >(val3);
28770 }
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28774 wxPyEndAllowThreads(__tstate);
28775 if (PyErr_Occurred()) SWIG_fail;
28776 }
28777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28778 return resultobj;
28779 fail:
28780 return NULL;
28781 }
28782
28783
28784 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28785 PyObject *resultobj = 0;
28786 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28787 void *argp1 = 0 ;
28788 int res1 = 0 ;
28789 PyObject *swig_obj[1] ;
28790
28791 if (!args) SWIG_fail;
28792 swig_obj[0] = args;
28793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28794 if (!SWIG_IsOK(res1)) {
28795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28796 }
28797 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 delete arg1;
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 resultobj = SWIG_Py_Void();
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj = 0;
28814 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28815 int arg2 ;
28816 int arg3 ;
28817 int arg4 ;
28818 void *argp1 = 0 ;
28819 int res1 = 0 ;
28820 int val2 ;
28821 int ecode2 = 0 ;
28822 int val3 ;
28823 int ecode3 = 0 ;
28824 int val4 ;
28825 int ecode4 = 0 ;
28826 PyObject * obj0 = 0 ;
28827 PyObject * obj1 = 0 ;
28828 PyObject * obj2 = 0 ;
28829 PyObject * obj3 = 0 ;
28830 char * kwnames[] = {
28831 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28832 };
28833
28834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28836 if (!SWIG_IsOK(res1)) {
28837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28838 }
28839 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28840 ecode2 = SWIG_AsVal_int(obj1, &val2);
28841 if (!SWIG_IsOK(ecode2)) {
28842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28843 }
28844 arg2 = static_cast< int >(val2);
28845 ecode3 = SWIG_AsVal_int(obj2, &val3);
28846 if (!SWIG_IsOK(ecode3)) {
28847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28848 }
28849 arg3 = static_cast< int >(val3);
28850 ecode4 = SWIG_AsVal_int(obj3, &val4);
28851 if (!SWIG_IsOK(ecode4)) {
28852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28853 }
28854 arg4 = static_cast< int >(val4);
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 (arg1)->Set(arg2,arg3,arg4);
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 resultobj = SWIG_Py_Void();
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28869 PyObject *resultobj = 0;
28870 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28871 int result;
28872 void *argp1 = 0 ;
28873 int res1 = 0 ;
28874 PyObject *swig_obj[1] ;
28875
28876 if (!args) SWIG_fail;
28877 swig_obj[0] = args;
28878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28879 if (!SWIG_IsOK(res1)) {
28880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28881 }
28882 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28883 {
28884 PyThreadState* __tstate = wxPyBeginAllowThreads();
28885 result = (int)(arg1)->GetFlags();
28886 wxPyEndAllowThreads(__tstate);
28887 if (PyErr_Occurred()) SWIG_fail;
28888 }
28889 resultobj = SWIG_From_int(static_cast< int >(result));
28890 return resultobj;
28891 fail:
28892 return NULL;
28893 }
28894
28895
28896 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897 PyObject *resultobj = 0;
28898 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28899 int result;
28900 void *argp1 = 0 ;
28901 int res1 = 0 ;
28902 PyObject *swig_obj[1] ;
28903
28904 if (!args) SWIG_fail;
28905 swig_obj[0] = args;
28906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28907 if (!SWIG_IsOK(res1)) {
28908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28909 }
28910 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 result = (int)(arg1)->GetKeyCode();
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 resultobj = SWIG_From_int(static_cast< int >(result));
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28925 PyObject *resultobj = 0;
28926 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28927 int result;
28928 void *argp1 = 0 ;
28929 int res1 = 0 ;
28930 PyObject *swig_obj[1] ;
28931
28932 if (!args) SWIG_fail;
28933 swig_obj[0] = args;
28934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28935 if (!SWIG_IsOK(res1)) {
28936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28937 }
28938 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28939 {
28940 PyThreadState* __tstate = wxPyBeginAllowThreads();
28941 result = (int)(arg1)->GetCommand();
28942 wxPyEndAllowThreads(__tstate);
28943 if (PyErr_Occurred()) SWIG_fail;
28944 }
28945 resultobj = SWIG_From_int(static_cast< int >(result));
28946 return resultobj;
28947 fail:
28948 return NULL;
28949 }
28950
28951
28952 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28953 PyObject *obj;
28954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28955 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28956 return SWIG_Py_Void();
28957 }
28958
28959 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28960 return SWIG_Python_InitShadowInstance(args);
28961 }
28962
28963 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj = 0;
28965 int arg1 ;
28966 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28967 wxAcceleratorTable *result = 0 ;
28968 PyObject * obj0 = 0 ;
28969 char * kwnames[] = {
28970 (char *) "n", NULL
28971 };
28972
28973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28974 {
28975 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28976 if (arg2) arg1 = PyList_Size(obj0);
28977 else arg1 = 0;
28978 }
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28993 PyObject *resultobj = 0;
28994 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28995 void *argp1 = 0 ;
28996 int res1 = 0 ;
28997 PyObject *swig_obj[1] ;
28998
28999 if (!args) SWIG_fail;
29000 swig_obj[0] = args;
29001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29002 if (!SWIG_IsOK(res1)) {
29003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29004 }
29005 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 delete arg1;
29009
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 resultobj = SWIG_Py_Void();
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29021 PyObject *resultobj = 0;
29022 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29023 bool result;
29024 void *argp1 = 0 ;
29025 int res1 = 0 ;
29026 PyObject *swig_obj[1] ;
29027
29028 if (!args) SWIG_fail;
29029 swig_obj[0] = args;
29030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29031 if (!SWIG_IsOK(res1)) {
29032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29033 }
29034 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29035 {
29036 PyThreadState* __tstate = wxPyBeginAllowThreads();
29037 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 {
29042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29043 }
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 PyObject *obj;
29052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29053 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29054 return SWIG_Py_Void();
29055 }
29056
29057 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29058 return SWIG_Python_InitShadowInstance(args);
29059 }
29060
29061 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29062 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29063 return 1;
29064 }
29065
29066
29067 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29068 PyObject *pyobj = 0;
29069
29070 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29071 return pyobj;
29072 }
29073
29074
29075 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29076 PyObject *resultobj = 0;
29077 wxString *arg1 = 0 ;
29078 wxAcceleratorEntry *result = 0 ;
29079 bool temp1 = false ;
29080 PyObject * obj0 = 0 ;
29081 char * kwnames[] = {
29082 (char *) "label", NULL
29083 };
29084
29085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29086 {
29087 arg1 = wxString_in_helper(obj0);
29088 if (arg1 == NULL) SWIG_fail;
29089 temp1 = true;
29090 }
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29094 wxPyEndAllowThreads(__tstate);
29095 if (PyErr_Occurred()) SWIG_fail;
29096 }
29097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29098 {
29099 if (temp1)
29100 delete arg1;
29101 }
29102 return resultobj;
29103 fail:
29104 {
29105 if (temp1)
29106 delete arg1;
29107 }
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN int PanelNameStr_set(PyObject *) {
29113 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29114 return 1;
29115 }
29116
29117
29118 SWIGINTERN PyObject *PanelNameStr_get(void) {
29119 PyObject *pyobj = 0;
29120
29121 {
29122 #if wxUSE_UNICODE
29123 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29124 #else
29125 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29126 #endif
29127 }
29128 return pyobj;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29133 PyObject *resultobj = 0;
29134 wxVisualAttributes *result = 0 ;
29135
29136 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29137 {
29138 PyThreadState* __tstate = wxPyBeginAllowThreads();
29139 result = (wxVisualAttributes *)new_wxVisualAttributes();
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 PyObject *resultobj = 0;
29152 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29153 void *argp1 = 0 ;
29154 int res1 = 0 ;
29155 PyObject *swig_obj[1] ;
29156
29157 if (!args) SWIG_fail;
29158 swig_obj[0] = args;
29159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29160 if (!SWIG_IsOK(res1)) {
29161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29162 }
29163 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 delete_wxVisualAttributes(arg1);
29167
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 resultobj = SWIG_Py_Void();
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29179 PyObject *resultobj = 0;
29180 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29181 wxFont *arg2 = (wxFont *) 0 ;
29182 void *argp1 = 0 ;
29183 int res1 = 0 ;
29184 void *argp2 = 0 ;
29185 int res2 = 0 ;
29186 PyObject *swig_obj[2] ;
29187
29188 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29192 }
29193 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29194 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29195 if (!SWIG_IsOK(res2)) {
29196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29197 }
29198 arg2 = reinterpret_cast< wxFont * >(argp2);
29199 if (arg1) (arg1)->font = *arg2;
29200
29201 resultobj = SWIG_Py_Void();
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29209 PyObject *resultobj = 0;
29210 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29211 wxFont *result = 0 ;
29212 void *argp1 = 0 ;
29213 int res1 = 0 ;
29214 PyObject *swig_obj[1] ;
29215
29216 if (!args) SWIG_fail;
29217 swig_obj[0] = args;
29218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29221 }
29222 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29223 result = (wxFont *)& ((arg1)->font);
29224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *resultobj = 0;
29233 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29234 wxColour *arg2 = (wxColour *) 0 ;
29235 void *argp1 = 0 ;
29236 int res1 = 0 ;
29237 void *argp2 = 0 ;
29238 int res2 = 0 ;
29239 PyObject *swig_obj[2] ;
29240
29241 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29243 if (!SWIG_IsOK(res1)) {
29244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29245 }
29246 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29247 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29248 if (!SWIG_IsOK(res2)) {
29249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29250 }
29251 arg2 = reinterpret_cast< wxColour * >(argp2);
29252 if (arg1) (arg1)->colFg = *arg2;
29253
29254 resultobj = SWIG_Py_Void();
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29262 PyObject *resultobj = 0;
29263 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29264 wxColour *result = 0 ;
29265 void *argp1 = 0 ;
29266 int res1 = 0 ;
29267 PyObject *swig_obj[1] ;
29268
29269 if (!args) SWIG_fail;
29270 swig_obj[0] = args;
29271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29272 if (!SWIG_IsOK(res1)) {
29273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29274 }
29275 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29276 result = (wxColour *)& ((arg1)->colFg);
29277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29285 PyObject *resultobj = 0;
29286 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29287 wxColour *arg2 = (wxColour *) 0 ;
29288 void *argp1 = 0 ;
29289 int res1 = 0 ;
29290 void *argp2 = 0 ;
29291 int res2 = 0 ;
29292 PyObject *swig_obj[2] ;
29293
29294 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29296 if (!SWIG_IsOK(res1)) {
29297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29298 }
29299 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29300 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29301 if (!SWIG_IsOK(res2)) {
29302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29303 }
29304 arg2 = reinterpret_cast< wxColour * >(argp2);
29305 if (arg1) (arg1)->colBg = *arg2;
29306
29307 resultobj = SWIG_Py_Void();
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29315 PyObject *resultobj = 0;
29316 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29317 wxColour *result = 0 ;
29318 void *argp1 = 0 ;
29319 int res1 = 0 ;
29320 PyObject *swig_obj[1] ;
29321
29322 if (!args) SWIG_fail;
29323 swig_obj[0] = args;
29324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29325 if (!SWIG_IsOK(res1)) {
29326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29327 }
29328 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29329 result = (wxColour *)& ((arg1)->colBg);
29330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 PyObject *obj;
29339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29340 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29341 return SWIG_Py_Void();
29342 }
29343
29344 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29345 return SWIG_Python_InitShadowInstance(args);
29346 }
29347
29348 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29349 PyObject *resultobj = 0;
29350 wxWindow *arg1 = (wxWindow *) 0 ;
29351 int arg2 = (int) (int)-1 ;
29352 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29353 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29354 wxSize const &arg4_defvalue = wxDefaultSize ;
29355 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29356 long arg5 = (long) 0 ;
29357 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29358 wxString *arg6 = (wxString *) &arg6_defvalue ;
29359 wxWindow *result = 0 ;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 int val2 ;
29363 int ecode2 = 0 ;
29364 wxPoint temp3 ;
29365 wxSize temp4 ;
29366 long val5 ;
29367 int ecode5 = 0 ;
29368 bool temp6 = false ;
29369 PyObject * obj0 = 0 ;
29370 PyObject * obj1 = 0 ;
29371 PyObject * obj2 = 0 ;
29372 PyObject * obj3 = 0 ;
29373 PyObject * obj4 = 0 ;
29374 PyObject * obj5 = 0 ;
29375 char * kwnames[] = {
29376 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29377 };
29378
29379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29381 if (!SWIG_IsOK(res1)) {
29382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29383 }
29384 arg1 = reinterpret_cast< wxWindow * >(argp1);
29385 if (obj1) {
29386 ecode2 = SWIG_AsVal_int(obj1, &val2);
29387 if (!SWIG_IsOK(ecode2)) {
29388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29389 }
29390 arg2 = static_cast< int >(val2);
29391 }
29392 if (obj2) {
29393 {
29394 arg3 = &temp3;
29395 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29396 }
29397 }
29398 if (obj3) {
29399 {
29400 arg4 = &temp4;
29401 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29402 }
29403 }
29404 if (obj4) {
29405 ecode5 = SWIG_AsVal_long(obj4, &val5);
29406 if (!SWIG_IsOK(ecode5)) {
29407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29408 }
29409 arg5 = static_cast< long >(val5);
29410 }
29411 if (obj5) {
29412 {
29413 arg6 = wxString_in_helper(obj5);
29414 if (arg6 == NULL) SWIG_fail;
29415 temp6 = true;
29416 }
29417 }
29418 {
29419 if (!wxPyCheckForApp()) SWIG_fail;
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29426 {
29427 if (temp6)
29428 delete arg6;
29429 }
29430 return resultobj;
29431 fail:
29432 {
29433 if (temp6)
29434 delete arg6;
29435 }
29436 return NULL;
29437 }
29438
29439
29440 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29441 PyObject *resultobj = 0;
29442 wxWindow *result = 0 ;
29443
29444 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29445 {
29446 if (!wxPyCheckForApp()) SWIG_fail;
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (wxWindow *)new wxWindow();
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxWindow *arg1 = (wxWindow *) 0 ;
29462 wxWindow *arg2 = (wxWindow *) 0 ;
29463 int arg3 = (int) (int)-1 ;
29464 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29465 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29466 wxSize const &arg5_defvalue = wxDefaultSize ;
29467 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29468 long arg6 = (long) 0 ;
29469 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29470 wxString *arg7 = (wxString *) &arg7_defvalue ;
29471 bool result;
29472 void *argp1 = 0 ;
29473 int res1 = 0 ;
29474 void *argp2 = 0 ;
29475 int res2 = 0 ;
29476 int val3 ;
29477 int ecode3 = 0 ;
29478 wxPoint temp4 ;
29479 wxSize temp5 ;
29480 long val6 ;
29481 int ecode6 = 0 ;
29482 bool temp7 = false ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 PyObject * obj2 = 0 ;
29486 PyObject * obj3 = 0 ;
29487 PyObject * obj4 = 0 ;
29488 PyObject * obj5 = 0 ;
29489 PyObject * obj6 = 0 ;
29490 char * kwnames[] = {
29491 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29492 };
29493
29494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29496 if (!SWIG_IsOK(res1)) {
29497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29498 }
29499 arg1 = reinterpret_cast< wxWindow * >(argp1);
29500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29501 if (!SWIG_IsOK(res2)) {
29502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29503 }
29504 arg2 = reinterpret_cast< wxWindow * >(argp2);
29505 if (obj2) {
29506 ecode3 = SWIG_AsVal_int(obj2, &val3);
29507 if (!SWIG_IsOK(ecode3)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29509 }
29510 arg3 = static_cast< int >(val3);
29511 }
29512 if (obj3) {
29513 {
29514 arg4 = &temp4;
29515 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29516 }
29517 }
29518 if (obj4) {
29519 {
29520 arg5 = &temp5;
29521 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29522 }
29523 }
29524 if (obj5) {
29525 ecode6 = SWIG_AsVal_long(obj5, &val6);
29526 if (!SWIG_IsOK(ecode6)) {
29527 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29528 }
29529 arg6 = static_cast< long >(val6);
29530 }
29531 if (obj6) {
29532 {
29533 arg7 = wxString_in_helper(obj6);
29534 if (arg7 == NULL) SWIG_fail;
29535 temp7 = true;
29536 }
29537 }
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 {
29545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29546 }
29547 {
29548 if (temp7)
29549 delete arg7;
29550 }
29551 return resultobj;
29552 fail:
29553 {
29554 if (temp7)
29555 delete arg7;
29556 }
29557 return NULL;
29558 }
29559
29560
29561 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj = 0;
29563 wxWindow *arg1 = (wxWindow *) 0 ;
29564 bool arg2 = (bool) false ;
29565 bool result;
29566 void *argp1 = 0 ;
29567 int res1 = 0 ;
29568 bool val2 ;
29569 int ecode2 = 0 ;
29570 PyObject * obj0 = 0 ;
29571 PyObject * obj1 = 0 ;
29572 char * kwnames[] = {
29573 (char *) "self",(char *) "force", NULL
29574 };
29575
29576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29578 if (!SWIG_IsOK(res1)) {
29579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29580 }
29581 arg1 = reinterpret_cast< wxWindow * >(argp1);
29582 if (obj1) {
29583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29584 if (!SWIG_IsOK(ecode2)) {
29585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29586 }
29587 arg2 = static_cast< bool >(val2);
29588 }
29589 {
29590 PyThreadState* __tstate = wxPyBeginAllowThreads();
29591 result = (bool)(arg1)->Close(arg2);
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 {
29596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29597 }
29598 return resultobj;
29599 fail:
29600 return NULL;
29601 }
29602
29603
29604 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29605 PyObject *resultobj = 0;
29606 wxWindow *arg1 = (wxWindow *) 0 ;
29607 bool result;
29608 void *argp1 = 0 ;
29609 int res1 = 0 ;
29610 PyObject *swig_obj[1] ;
29611
29612 if (!args) SWIG_fail;
29613 swig_obj[0] = args;
29614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29615 if (!SWIG_IsOK(res1)) {
29616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29617 }
29618 arg1 = reinterpret_cast< wxWindow * >(argp1);
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (bool)(arg1)->Destroy();
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 {
29626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29627 }
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29635 PyObject *resultobj = 0;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 bool result;
29638 void *argp1 = 0 ;
29639 int res1 = 0 ;
29640 PyObject *swig_obj[1] ;
29641
29642 if (!args) SWIG_fail;
29643 swig_obj[0] = args;
29644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29645 if (!SWIG_IsOK(res1)) {
29646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29647 }
29648 arg1 = reinterpret_cast< wxWindow * >(argp1);
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (bool)(arg1)->DestroyChildren();
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxWindow *arg1 = (wxWindow *) 0 ;
29667 bool result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxWindow * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj = 0;
29696 wxWindow *arg1 = (wxWindow *) 0 ;
29697 wxString *arg2 = 0 ;
29698 void *argp1 = 0 ;
29699 int res1 = 0 ;
29700 bool temp2 = false ;
29701 PyObject * obj0 = 0 ;
29702 PyObject * obj1 = 0 ;
29703 char * kwnames[] = {
29704 (char *) "self",(char *) "label", NULL
29705 };
29706
29707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29709 if (!SWIG_IsOK(res1)) {
29710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29711 }
29712 arg1 = reinterpret_cast< wxWindow * >(argp1);
29713 {
29714 arg2 = wxString_in_helper(obj1);
29715 if (arg2 == NULL) SWIG_fail;
29716 temp2 = true;
29717 }
29718 {
29719 PyThreadState* __tstate = wxPyBeginAllowThreads();
29720 (arg1)->SetLabel((wxString const &)*arg2);
29721 wxPyEndAllowThreads(__tstate);
29722 if (PyErr_Occurred()) SWIG_fail;
29723 }
29724 resultobj = SWIG_Py_Void();
29725 {
29726 if (temp2)
29727 delete arg2;
29728 }
29729 return resultobj;
29730 fail:
29731 {
29732 if (temp2)
29733 delete arg2;
29734 }
29735 return NULL;
29736 }
29737
29738
29739 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29740 PyObject *resultobj = 0;
29741 wxWindow *arg1 = (wxWindow *) 0 ;
29742 wxString result;
29743 void *argp1 = 0 ;
29744 int res1 = 0 ;
29745 PyObject *swig_obj[1] ;
29746
29747 if (!args) SWIG_fail;
29748 swig_obj[0] = args;
29749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29750 if (!SWIG_IsOK(res1)) {
29751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29752 }
29753 arg1 = reinterpret_cast< wxWindow * >(argp1);
29754 {
29755 PyThreadState* __tstate = wxPyBeginAllowThreads();
29756 result = ((wxWindow const *)arg1)->GetLabel();
29757 wxPyEndAllowThreads(__tstate);
29758 if (PyErr_Occurred()) SWIG_fail;
29759 }
29760 {
29761 #if wxUSE_UNICODE
29762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29763 #else
29764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29765 #endif
29766 }
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj = 0;
29775 wxWindow *arg1 = (wxWindow *) 0 ;
29776 wxString *arg2 = 0 ;
29777 void *argp1 = 0 ;
29778 int res1 = 0 ;
29779 bool temp2 = false ;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782 char * kwnames[] = {
29783 (char *) "self",(char *) "name", NULL
29784 };
29785
29786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29788 if (!SWIG_IsOK(res1)) {
29789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29790 }
29791 arg1 = reinterpret_cast< wxWindow * >(argp1);
29792 {
29793 arg2 = wxString_in_helper(obj1);
29794 if (arg2 == NULL) SWIG_fail;
29795 temp2 = true;
29796 }
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 (arg1)->SetName((wxString const &)*arg2);
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 resultobj = SWIG_Py_Void();
29804 {
29805 if (temp2)
29806 delete arg2;
29807 }
29808 return resultobj;
29809 fail:
29810 {
29811 if (temp2)
29812 delete arg2;
29813 }
29814 return NULL;
29815 }
29816
29817
29818 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29819 PyObject *resultobj = 0;
29820 wxWindow *arg1 = (wxWindow *) 0 ;
29821 wxString result;
29822 void *argp1 = 0 ;
29823 int res1 = 0 ;
29824 PyObject *swig_obj[1] ;
29825
29826 if (!args) SWIG_fail;
29827 swig_obj[0] = args;
29828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29829 if (!SWIG_IsOK(res1)) {
29830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29831 }
29832 arg1 = reinterpret_cast< wxWindow * >(argp1);
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = ((wxWindow const *)arg1)->GetName();
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 {
29840 #if wxUSE_UNICODE
29841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29842 #else
29843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29844 #endif
29845 }
29846 return resultobj;
29847 fail:
29848 return NULL;
29849 }
29850
29851
29852 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29853 PyObject *resultobj = 0;
29854 wxWindow *arg1 = (wxWindow *) 0 ;
29855 wxWindowVariant arg2 ;
29856 void *argp1 = 0 ;
29857 int res1 = 0 ;
29858 int val2 ;
29859 int ecode2 = 0 ;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 char * kwnames[] = {
29863 (char *) "self",(char *) "variant", NULL
29864 };
29865
29866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29868 if (!SWIG_IsOK(res1)) {
29869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29870 }
29871 arg1 = reinterpret_cast< wxWindow * >(argp1);
29872 ecode2 = SWIG_AsVal_int(obj1, &val2);
29873 if (!SWIG_IsOK(ecode2)) {
29874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29875 }
29876 arg2 = static_cast< wxWindowVariant >(val2);
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 (arg1)->SetWindowVariant(arg2);
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 resultobj = SWIG_Py_Void();
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxWindow *arg1 = (wxWindow *) 0 ;
29893 wxWindowVariant result;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 PyObject *swig_obj[1] ;
29897
29898 if (!args) SWIG_fail;
29899 swig_obj[0] = args;
29900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29901 if (!SWIG_IsOK(res1)) {
29902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29903 }
29904 arg1 = reinterpret_cast< wxWindow * >(argp1);
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 resultobj = SWIG_From_int(static_cast< int >(result));
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj = 0;
29920 wxWindow *arg1 = (wxWindow *) 0 ;
29921 int arg2 ;
29922 void *argp1 = 0 ;
29923 int res1 = 0 ;
29924 int val2 ;
29925 int ecode2 = 0 ;
29926 PyObject * obj0 = 0 ;
29927 PyObject * obj1 = 0 ;
29928 char * kwnames[] = {
29929 (char *) "self",(char *) "winid", NULL
29930 };
29931
29932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29934 if (!SWIG_IsOK(res1)) {
29935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29936 }
29937 arg1 = reinterpret_cast< wxWindow * >(argp1);
29938 ecode2 = SWIG_AsVal_int(obj1, &val2);
29939 if (!SWIG_IsOK(ecode2)) {
29940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29941 }
29942 arg2 = static_cast< int >(val2);
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 (arg1)->SetId(arg2);
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 resultobj = SWIG_Py_Void();
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29957 PyObject *resultobj = 0;
29958 wxWindow *arg1 = (wxWindow *) 0 ;
29959 int result;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 PyObject *swig_obj[1] ;
29963
29964 if (!args) SWIG_fail;
29965 swig_obj[0] = args;
29966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29967 if (!SWIG_IsOK(res1)) {
29968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29969 }
29970 arg1 = reinterpret_cast< wxWindow * >(argp1);
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (int)((wxWindow const *)arg1)->GetId();
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 resultobj = SWIG_From_int(static_cast< int >(result));
29978 return resultobj;
29979 fail:
29980 return NULL;
29981 }
29982
29983
29984 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29985 PyObject *resultobj = 0;
29986 int result;
29987
29988 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29989 {
29990 PyThreadState* __tstate = wxPyBeginAllowThreads();
29991 result = (int)wxWindow::NewControlId();
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 resultobj = SWIG_From_int(static_cast< int >(result));
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30003 PyObject *resultobj = 0;
30004 int arg1 ;
30005 int result;
30006 int val1 ;
30007 int ecode1 = 0 ;
30008 PyObject * obj0 = 0 ;
30009 char * kwnames[] = {
30010 (char *) "winid", NULL
30011 };
30012
30013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30014 ecode1 = SWIG_AsVal_int(obj0, &val1);
30015 if (!SWIG_IsOK(ecode1)) {
30016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30017 }
30018 arg1 = static_cast< int >(val1);
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (int)wxWindow::NextControlId(arg1);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_From_int(static_cast< int >(result));
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj = 0;
30034 int arg1 ;
30035 int result;
30036 int val1 ;
30037 int ecode1 = 0 ;
30038 PyObject * obj0 = 0 ;
30039 char * kwnames[] = {
30040 (char *) "winid", NULL
30041 };
30042
30043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30044 ecode1 = SWIG_AsVal_int(obj0, &val1);
30045 if (!SWIG_IsOK(ecode1)) {
30046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30047 }
30048 arg1 = static_cast< int >(val1);
30049 {
30050 PyThreadState* __tstate = wxPyBeginAllowThreads();
30051 result = (int)wxWindow::PrevControlId(arg1);
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 resultobj = SWIG_From_int(static_cast< int >(result));
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj = 0;
30064 wxWindow *arg1 = (wxWindow *) 0 ;
30065 wxSize *arg2 = 0 ;
30066 void *argp1 = 0 ;
30067 int res1 = 0 ;
30068 wxSize temp2 ;
30069 PyObject * obj0 = 0 ;
30070 PyObject * obj1 = 0 ;
30071 char * kwnames[] = {
30072 (char *) "self",(char *) "size", NULL
30073 };
30074
30075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30077 if (!SWIG_IsOK(res1)) {
30078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30079 }
30080 arg1 = reinterpret_cast< wxWindow * >(argp1);
30081 {
30082 arg2 = &temp2;
30083 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30084 }
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 (arg1)->SetSize((wxSize const &)*arg2);
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_Py_Void();
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj = 0;
30100 wxWindow *arg1 = (wxWindow *) 0 ;
30101 int arg2 ;
30102 int arg3 ;
30103 int arg4 ;
30104 int arg5 ;
30105 int arg6 = (int) wxSIZE_AUTO ;
30106 void *argp1 = 0 ;
30107 int res1 = 0 ;
30108 int val2 ;
30109 int ecode2 = 0 ;
30110 int val3 ;
30111 int ecode3 = 0 ;
30112 int val4 ;
30113 int ecode4 = 0 ;
30114 int val5 ;
30115 int ecode5 = 0 ;
30116 int val6 ;
30117 int ecode6 = 0 ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 PyObject * obj2 = 0 ;
30121 PyObject * obj3 = 0 ;
30122 PyObject * obj4 = 0 ;
30123 PyObject * obj5 = 0 ;
30124 char * kwnames[] = {
30125 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30126 };
30127
30128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30130 if (!SWIG_IsOK(res1)) {
30131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30132 }
30133 arg1 = reinterpret_cast< wxWindow * >(argp1);
30134 ecode2 = SWIG_AsVal_int(obj1, &val2);
30135 if (!SWIG_IsOK(ecode2)) {
30136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30137 }
30138 arg2 = static_cast< int >(val2);
30139 ecode3 = SWIG_AsVal_int(obj2, &val3);
30140 if (!SWIG_IsOK(ecode3)) {
30141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30142 }
30143 arg3 = static_cast< int >(val3);
30144 ecode4 = SWIG_AsVal_int(obj3, &val4);
30145 if (!SWIG_IsOK(ecode4)) {
30146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30147 }
30148 arg4 = static_cast< int >(val4);
30149 ecode5 = SWIG_AsVal_int(obj4, &val5);
30150 if (!SWIG_IsOK(ecode5)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30152 }
30153 arg5 = static_cast< int >(val5);
30154 if (obj5) {
30155 ecode6 = SWIG_AsVal_int(obj5, &val6);
30156 if (!SWIG_IsOK(ecode6)) {
30157 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30158 }
30159 arg6 = static_cast< int >(val6);
30160 }
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 resultobj = SWIG_Py_Void();
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj = 0;
30176 wxWindow *arg1 = (wxWindow *) 0 ;
30177 wxRect *arg2 = 0 ;
30178 int arg3 = (int) wxSIZE_AUTO ;
30179 void *argp1 = 0 ;
30180 int res1 = 0 ;
30181 wxRect temp2 ;
30182 int val3 ;
30183 int ecode3 = 0 ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 PyObject * obj2 = 0 ;
30187 char * kwnames[] = {
30188 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30189 };
30190
30191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30193 if (!SWIG_IsOK(res1)) {
30194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30195 }
30196 arg1 = reinterpret_cast< wxWindow * >(argp1);
30197 {
30198 arg2 = &temp2;
30199 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30200 }
30201 if (obj2) {
30202 ecode3 = SWIG_AsVal_int(obj2, &val3);
30203 if (!SWIG_IsOK(ecode3)) {
30204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30205 }
30206 arg3 = static_cast< int >(val3);
30207 }
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 resultobj = SWIG_Py_Void();
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 int arg2 ;
30225 int arg3 ;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 int val2 ;
30229 int ecode2 = 0 ;
30230 int val3 ;
30231 int ecode3 = 0 ;
30232 PyObject * obj0 = 0 ;
30233 PyObject * obj1 = 0 ;
30234 PyObject * obj2 = 0 ;
30235 char * kwnames[] = {
30236 (char *) "self",(char *) "width",(char *) "height", NULL
30237 };
30238
30239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30241 if (!SWIG_IsOK(res1)) {
30242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30243 }
30244 arg1 = reinterpret_cast< wxWindow * >(argp1);
30245 ecode2 = SWIG_AsVal_int(obj1, &val2);
30246 if (!SWIG_IsOK(ecode2)) {
30247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30248 }
30249 arg2 = static_cast< int >(val2);
30250 ecode3 = SWIG_AsVal_int(obj2, &val3);
30251 if (!SWIG_IsOK(ecode3)) {
30252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30253 }
30254 arg3 = static_cast< int >(val3);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 (arg1)->SetSize(arg2,arg3);
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_Py_Void();
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 wxPoint *arg2 = 0 ;
30272 int arg3 = (int) wxSIZE_USE_EXISTING ;
30273 void *argp1 = 0 ;
30274 int res1 = 0 ;
30275 wxPoint temp2 ;
30276 int val3 ;
30277 int ecode3 = 0 ;
30278 PyObject * obj0 = 0 ;
30279 PyObject * obj1 = 0 ;
30280 PyObject * obj2 = 0 ;
30281 char * kwnames[] = {
30282 (char *) "self",(char *) "pt",(char *) "flags", NULL
30283 };
30284
30285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30287 if (!SWIG_IsOK(res1)) {
30288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30289 }
30290 arg1 = reinterpret_cast< wxWindow * >(argp1);
30291 {
30292 arg2 = &temp2;
30293 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30294 }
30295 if (obj2) {
30296 ecode3 = SWIG_AsVal_int(obj2, &val3);
30297 if (!SWIG_IsOK(ecode3)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30299 }
30300 arg3 = static_cast< int >(val3);
30301 }
30302 {
30303 PyThreadState* __tstate = wxPyBeginAllowThreads();
30304 (arg1)->Move((wxPoint const &)*arg2,arg3);
30305 wxPyEndAllowThreads(__tstate);
30306 if (PyErr_Occurred()) SWIG_fail;
30307 }
30308 resultobj = SWIG_Py_Void();
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj = 0;
30317 wxWindow *arg1 = (wxWindow *) 0 ;
30318 int arg2 ;
30319 int arg3 ;
30320 int arg4 = (int) wxSIZE_USE_EXISTING ;
30321 void *argp1 = 0 ;
30322 int res1 = 0 ;
30323 int val2 ;
30324 int ecode2 = 0 ;
30325 int val3 ;
30326 int ecode3 = 0 ;
30327 int val4 ;
30328 int ecode4 = 0 ;
30329 PyObject * obj0 = 0 ;
30330 PyObject * obj1 = 0 ;
30331 PyObject * obj2 = 0 ;
30332 PyObject * obj3 = 0 ;
30333 char * kwnames[] = {
30334 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30335 };
30336
30337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30339 if (!SWIG_IsOK(res1)) {
30340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30341 }
30342 arg1 = reinterpret_cast< wxWindow * >(argp1);
30343 ecode2 = SWIG_AsVal_int(obj1, &val2);
30344 if (!SWIG_IsOK(ecode2)) {
30345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30346 }
30347 arg2 = static_cast< int >(val2);
30348 ecode3 = SWIG_AsVal_int(obj2, &val3);
30349 if (!SWIG_IsOK(ecode3)) {
30350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30351 }
30352 arg3 = static_cast< int >(val3);
30353 if (obj3) {
30354 ecode4 = SWIG_AsVal_int(obj3, &val4);
30355 if (!SWIG_IsOK(ecode4)) {
30356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30357 }
30358 arg4 = static_cast< int >(val4);
30359 }
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 (arg1)->Move(arg2,arg3,arg4);
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 resultobj = SWIG_Py_Void();
30367 return resultobj;
30368 fail:
30369 return NULL;
30370 }
30371
30372
30373 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30374 PyObject *resultobj = 0;
30375 wxWindow *arg1 = (wxWindow *) 0 ;
30376 wxSize const &arg2_defvalue = wxDefaultSize ;
30377 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 wxSize temp2 ;
30381 PyObject * obj0 = 0 ;
30382 PyObject * obj1 = 0 ;
30383 char * kwnames[] = {
30384 (char *) "self",(char *) "size", NULL
30385 };
30386
30387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30389 if (!SWIG_IsOK(res1)) {
30390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30391 }
30392 arg1 = reinterpret_cast< wxWindow * >(argp1);
30393 if (obj1) {
30394 {
30395 arg2 = &temp2;
30396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30397 }
30398 }
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_Py_Void();
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 PyObject *resultobj = 0;
30414 wxWindow *arg1 = (wxWindow *) 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 PyObject *swig_obj[1] ;
30418
30419 if (!args) SWIG_fail;
30420 swig_obj[0] = args;
30421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30424 }
30425 arg1 = reinterpret_cast< wxWindow * >(argp1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->Raise();
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30440 PyObject *resultobj = 0;
30441 wxWindow *arg1 = (wxWindow *) 0 ;
30442 void *argp1 = 0 ;
30443 int res1 = 0 ;
30444 PyObject *swig_obj[1] ;
30445
30446 if (!args) SWIG_fail;
30447 swig_obj[0] = args;
30448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30449 if (!SWIG_IsOK(res1)) {
30450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30451 }
30452 arg1 = reinterpret_cast< wxWindow * >(argp1);
30453 {
30454 PyThreadState* __tstate = wxPyBeginAllowThreads();
30455 (arg1)->Lower();
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 resultobj = SWIG_Py_Void();
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30467 PyObject *resultobj = 0;
30468 wxWindow *arg1 = (wxWindow *) 0 ;
30469 wxSize *arg2 = 0 ;
30470 void *argp1 = 0 ;
30471 int res1 = 0 ;
30472 wxSize temp2 ;
30473 PyObject * obj0 = 0 ;
30474 PyObject * obj1 = 0 ;
30475 char * kwnames[] = {
30476 (char *) "self",(char *) "size", NULL
30477 };
30478
30479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30481 if (!SWIG_IsOK(res1)) {
30482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30483 }
30484 arg1 = reinterpret_cast< wxWindow * >(argp1);
30485 {
30486 arg2 = &temp2;
30487 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30488 }
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 (arg1)->SetClientSize((wxSize const &)*arg2);
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_Py_Void();
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30503 PyObject *resultobj = 0;
30504 wxWindow *arg1 = (wxWindow *) 0 ;
30505 int arg2 ;
30506 int arg3 ;
30507 void *argp1 = 0 ;
30508 int res1 = 0 ;
30509 int val2 ;
30510 int ecode2 = 0 ;
30511 int val3 ;
30512 int ecode3 = 0 ;
30513 PyObject * obj0 = 0 ;
30514 PyObject * obj1 = 0 ;
30515 PyObject * obj2 = 0 ;
30516 char * kwnames[] = {
30517 (char *) "self",(char *) "width",(char *) "height", NULL
30518 };
30519
30520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30524 }
30525 arg1 = reinterpret_cast< wxWindow * >(argp1);
30526 ecode2 = SWIG_AsVal_int(obj1, &val2);
30527 if (!SWIG_IsOK(ecode2)) {
30528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30529 }
30530 arg2 = static_cast< int >(val2);
30531 ecode3 = SWIG_AsVal_int(obj2, &val3);
30532 if (!SWIG_IsOK(ecode3)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30534 }
30535 arg3 = static_cast< int >(val3);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 (arg1)->SetClientSize(arg2,arg3);
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_Py_Void();
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj = 0;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 wxRect *arg2 = 0 ;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 wxRect temp2 ;
30556 PyObject * obj0 = 0 ;
30557 PyObject * obj1 = 0 ;
30558 char * kwnames[] = {
30559 (char *) "self",(char *) "rect", NULL
30560 };
30561
30562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30566 }
30567 arg1 = reinterpret_cast< wxWindow * >(argp1);
30568 {
30569 arg2 = &temp2;
30570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30571 }
30572 {
30573 PyThreadState* __tstate = wxPyBeginAllowThreads();
30574 (arg1)->SetClientSize((wxRect const &)*arg2);
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 resultobj = SWIG_Py_Void();
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxWindow *arg1 = (wxWindow *) 0 ;
30588 wxPoint result;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 PyObject *swig_obj[1] ;
30592
30593 if (!args) SWIG_fail;
30594 swig_obj[0] = args;
30595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 result = ((wxWindow const *)arg1)->GetPosition();
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 PyObject *resultobj = 0;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 int *arg2 = (int *) 0 ;
30617 int *arg3 = (int *) 0 ;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 int temp2 ;
30621 int res2 = SWIG_TMPOBJ ;
30622 int temp3 ;
30623 int res3 = SWIG_TMPOBJ ;
30624 PyObject *swig_obj[1] ;
30625
30626 arg2 = &temp2;
30627 arg3 = &temp3;
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30633 }
30634 arg1 = reinterpret_cast< wxWindow * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 resultobj = SWIG_Py_Void();
30642 if (SWIG_IsTmpObj(res2)) {
30643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30644 } else {
30645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30647 }
30648 if (SWIG_IsTmpObj(res3)) {
30649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30650 } else {
30651 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 wxPoint result;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30673 }
30674 arg1 = reinterpret_cast< wxWindow * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = ((wxWindow const *)arg1)->GetScreenPosition();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxWindow *arg1 = (wxWindow *) 0 ;
30691 int *arg2 = (int *) 0 ;
30692 int *arg3 = (int *) 0 ;
30693 void *argp1 = 0 ;
30694 int res1 = 0 ;
30695 int temp2 ;
30696 int res2 = SWIG_TMPOBJ ;
30697 int temp3 ;
30698 int res3 = SWIG_TMPOBJ ;
30699 PyObject *swig_obj[1] ;
30700
30701 arg2 = &temp2;
30702 arg3 = &temp3;
30703 if (!args) SWIG_fail;
30704 swig_obj[0] = args;
30705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30706 if (!SWIG_IsOK(res1)) {
30707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30708 }
30709 arg1 = reinterpret_cast< wxWindow * >(argp1);
30710 {
30711 PyThreadState* __tstate = wxPyBeginAllowThreads();
30712 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 resultobj = SWIG_Py_Void();
30717 if (SWIG_IsTmpObj(res2)) {
30718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30719 } else {
30720 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30722 }
30723 if (SWIG_IsTmpObj(res3)) {
30724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30725 } else {
30726 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30728 }
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30736 PyObject *resultobj = 0;
30737 wxWindow *arg1 = (wxWindow *) 0 ;
30738 wxRect result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 PyObject *swig_obj[1] ;
30742
30743 if (!args) SWIG_fail;
30744 swig_obj[0] = args;
30745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxWindow * >(argp1);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = ((wxWindow const *)arg1)->GetScreenRect();
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxWindow *arg1 = (wxWindow *) 0 ;
30766 wxSize result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxWindow * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxWindow const *)arg1)->GetSize();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 int *arg2 = (int *) 0 ;
30795 int *arg3 = (int *) 0 ;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 int temp2 ;
30799 int res2 = SWIG_TMPOBJ ;
30800 int temp3 ;
30801 int res3 = SWIG_TMPOBJ ;
30802 PyObject *swig_obj[1] ;
30803
30804 arg2 = &temp2;
30805 arg3 = &temp3;
30806 if (!args) SWIG_fail;
30807 swig_obj[0] = args;
30808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30809 if (!SWIG_IsOK(res1)) {
30810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30811 }
30812 arg1 = reinterpret_cast< wxWindow * >(argp1);
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 resultobj = SWIG_Py_Void();
30820 if (SWIG_IsTmpObj(res2)) {
30821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30822 } else {
30823 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30825 }
30826 if (SWIG_IsTmpObj(res3)) {
30827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30828 } else {
30829 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30831 }
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30839 PyObject *resultobj = 0;
30840 wxWindow *arg1 = (wxWindow *) 0 ;
30841 wxRect result;
30842 void *argp1 = 0 ;
30843 int res1 = 0 ;
30844 PyObject *swig_obj[1] ;
30845
30846 if (!args) SWIG_fail;
30847 swig_obj[0] = args;
30848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30849 if (!SWIG_IsOK(res1)) {
30850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30851 }
30852 arg1 = reinterpret_cast< wxWindow * >(argp1);
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = ((wxWindow const *)arg1)->GetRect();
30856 wxPyEndAllowThreads(__tstate);
30857 if (PyErr_Occurred()) SWIG_fail;
30858 }
30859 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867 PyObject *resultobj = 0;
30868 wxWindow *arg1 = (wxWindow *) 0 ;
30869 wxSize result;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 PyObject *swig_obj[1] ;
30873
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30879 }
30880 arg1 = reinterpret_cast< wxWindow * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = ((wxWindow const *)arg1)->GetClientSize();
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 int *arg2 = (int *) 0 ;
30898 int *arg3 = (int *) 0 ;
30899 void *argp1 = 0 ;
30900 int res1 = 0 ;
30901 int temp2 ;
30902 int res2 = SWIG_TMPOBJ ;
30903 int temp3 ;
30904 int res3 = SWIG_TMPOBJ ;
30905 PyObject *swig_obj[1] ;
30906
30907 arg2 = &temp2;
30908 arg3 = &temp3;
30909 if (!args) SWIG_fail;
30910 swig_obj[0] = args;
30911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30912 if (!SWIG_IsOK(res1)) {
30913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30914 }
30915 arg1 = reinterpret_cast< wxWindow * >(argp1);
30916 {
30917 PyThreadState* __tstate = wxPyBeginAllowThreads();
30918 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 resultobj = SWIG_Py_Void();
30923 if (SWIG_IsTmpObj(res2)) {
30924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30925 } else {
30926 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30928 }
30929 if (SWIG_IsTmpObj(res3)) {
30930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30931 } else {
30932 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30934 }
30935 return resultobj;
30936 fail:
30937 return NULL;
30938 }
30939
30940
30941 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30942 PyObject *resultobj = 0;
30943 wxWindow *arg1 = (wxWindow *) 0 ;
30944 wxPoint result;
30945 void *argp1 = 0 ;
30946 int res1 = 0 ;
30947 PyObject *swig_obj[1] ;
30948
30949 if (!args) SWIG_fail;
30950 swig_obj[0] = args;
30951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30954 }
30955 arg1 = reinterpret_cast< wxWindow * >(argp1);
30956 {
30957 PyThreadState* __tstate = wxPyBeginAllowThreads();
30958 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30959 wxPyEndAllowThreads(__tstate);
30960 if (PyErr_Occurred()) SWIG_fail;
30961 }
30962 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30970 PyObject *resultobj = 0;
30971 wxWindow *arg1 = (wxWindow *) 0 ;
30972 wxRect result;
30973 void *argp1 = 0 ;
30974 int res1 = 0 ;
30975 PyObject *swig_obj[1] ;
30976
30977 if (!args) SWIG_fail;
30978 swig_obj[0] = args;
30979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = ((wxWindow const *)arg1)->GetClientRect();
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 wxSize result;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 PyObject *swig_obj[1] ;
31004
31005 if (!args) SWIG_fail;
31006 swig_obj[0] = args;
31007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31010 }
31011 arg1 = reinterpret_cast< wxWindow * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = ((wxWindow const *)arg1)->GetBestSize();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxWindow *arg1 = (wxWindow *) 0 ;
31028 int *arg2 = (int *) 0 ;
31029 int *arg3 = (int *) 0 ;
31030 void *argp1 = 0 ;
31031 int res1 = 0 ;
31032 int temp2 ;
31033 int res2 = SWIG_TMPOBJ ;
31034 int temp3 ;
31035 int res3 = SWIG_TMPOBJ ;
31036 PyObject *swig_obj[1] ;
31037
31038 arg2 = &temp2;
31039 arg3 = &temp3;
31040 if (!args) SWIG_fail;
31041 swig_obj[0] = args;
31042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31043 if (!SWIG_IsOK(res1)) {
31044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31045 }
31046 arg1 = reinterpret_cast< wxWindow * >(argp1);
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_Py_Void();
31054 if (SWIG_IsTmpObj(res2)) {
31055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31056 } else {
31057 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31059 }
31060 if (SWIG_IsTmpObj(res3)) {
31061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31062 } else {
31063 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31065 }
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31073 PyObject *resultobj = 0;
31074 wxWindow *arg1 = (wxWindow *) 0 ;
31075 void *argp1 = 0 ;
31076 int res1 = 0 ;
31077 PyObject *swig_obj[1] ;
31078
31079 if (!args) SWIG_fail;
31080 swig_obj[0] = args;
31081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31084 }
31085 arg1 = reinterpret_cast< wxWindow * >(argp1);
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 (arg1)->InvalidateBestSize();
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_Py_Void();
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 wxWindow *arg1 = (wxWindow *) 0 ;
31102 wxSize *arg2 = 0 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 wxSize temp2 ;
31106 PyObject * obj0 = 0 ;
31107 PyObject * obj1 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "size", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 {
31119 arg2 = &temp2;
31120 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31121 }
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 resultobj = SWIG_Py_Void();
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31136 PyObject *resultobj = 0;
31137 wxWindow *arg1 = (wxWindow *) 0 ;
31138 wxSize result;
31139 void *argp1 = 0 ;
31140 int res1 = 0 ;
31141 PyObject *swig_obj[1] ;
31142
31143 if (!args) SWIG_fail;
31144 swig_obj[0] = args;
31145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31146 if (!SWIG_IsOK(res1)) {
31147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31148 }
31149 arg1 = reinterpret_cast< wxWindow * >(argp1);
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31164 PyObject *resultobj = 0;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 wxSize result;
31167 void *argp1 = 0 ;
31168 int res1 = 0 ;
31169 PyObject *swig_obj[1] ;
31170
31171 if (!args) SWIG_fail;
31172 swig_obj[0] = args;
31173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31174 if (!SWIG_IsOK(res1)) {
31175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31176 }
31177 arg1 = reinterpret_cast< wxWindow * >(argp1);
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31181 wxPyEndAllowThreads(__tstate);
31182 if (PyErr_Occurred()) SWIG_fail;
31183 }
31184 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31192 PyObject *resultobj = 0;
31193 wxWindow *arg1 = (wxWindow *) 0 ;
31194 int arg2 = (int) wxBOTH ;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 int val2 ;
31198 int ecode2 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "self",(char *) "direction", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31207 if (!SWIG_IsOK(res1)) {
31208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31209 }
31210 arg1 = reinterpret_cast< wxWindow * >(argp1);
31211 if (obj1) {
31212 ecode2 = SWIG_AsVal_int(obj1, &val2);
31213 if (!SWIG_IsOK(ecode2)) {
31214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31215 }
31216 arg2 = static_cast< int >(val2);
31217 }
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 (arg1)->Center(arg2);
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_Py_Void();
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31232 PyObject *resultobj = 0;
31233 wxWindow *arg1 = (wxWindow *) 0 ;
31234 int arg2 = (int) wxBOTH ;
31235 void *argp1 = 0 ;
31236 int res1 = 0 ;
31237 int val2 ;
31238 int ecode2 = 0 ;
31239 PyObject * obj0 = 0 ;
31240 PyObject * obj1 = 0 ;
31241 char * kwnames[] = {
31242 (char *) "self",(char *) "dir", NULL
31243 };
31244
31245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31249 }
31250 arg1 = reinterpret_cast< wxWindow * >(argp1);
31251 if (obj1) {
31252 ecode2 = SWIG_AsVal_int(obj1, &val2);
31253 if (!SWIG_IsOK(ecode2)) {
31254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31255 }
31256 arg2 = static_cast< int >(val2);
31257 }
31258 {
31259 PyThreadState* __tstate = wxPyBeginAllowThreads();
31260 (arg1)->CenterOnParent(arg2);
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 resultobj = SWIG_Py_Void();
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31272 PyObject *resultobj = 0;
31273 wxWindow *arg1 = (wxWindow *) 0 ;
31274 void *argp1 = 0 ;
31275 int res1 = 0 ;
31276 PyObject *swig_obj[1] ;
31277
31278 if (!args) SWIG_fail;
31279 swig_obj[0] = args;
31280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31281 if (!SWIG_IsOK(res1)) {
31282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31283 }
31284 arg1 = reinterpret_cast< wxWindow * >(argp1);
31285 {
31286 PyThreadState* __tstate = wxPyBeginAllowThreads();
31287 (arg1)->Fit();
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 resultobj = SWIG_Py_Void();
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31299 PyObject *resultobj = 0;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 void *argp1 = 0 ;
31302 int res1 = 0 ;
31303 PyObject *swig_obj[1] ;
31304
31305 if (!args) SWIG_fail;
31306 swig_obj[0] = args;
31307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31308 if (!SWIG_IsOK(res1)) {
31309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31310 }
31311 arg1 = reinterpret_cast< wxWindow * >(argp1);
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 (arg1)->FitInside();
31315 wxPyEndAllowThreads(__tstate);
31316 if (PyErr_Occurred()) SWIG_fail;
31317 }
31318 resultobj = SWIG_Py_Void();
31319 return resultobj;
31320 fail:
31321 return NULL;
31322 }
31323
31324
31325 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31326 PyObject *resultobj = 0;
31327 wxWindow *arg1 = (wxWindow *) 0 ;
31328 int arg2 ;
31329 int arg3 ;
31330 int arg4 = (int) -1 ;
31331 int arg5 = (int) -1 ;
31332 int arg6 = (int) -1 ;
31333 int arg7 = (int) -1 ;
31334 void *argp1 = 0 ;
31335 int res1 = 0 ;
31336 int val2 ;
31337 int ecode2 = 0 ;
31338 int val3 ;
31339 int ecode3 = 0 ;
31340 int val4 ;
31341 int ecode4 = 0 ;
31342 int val5 ;
31343 int ecode5 = 0 ;
31344 int val6 ;
31345 int ecode6 = 0 ;
31346 int val7 ;
31347 int ecode7 = 0 ;
31348 PyObject * obj0 = 0 ;
31349 PyObject * obj1 = 0 ;
31350 PyObject * obj2 = 0 ;
31351 PyObject * obj3 = 0 ;
31352 PyObject * obj4 = 0 ;
31353 PyObject * obj5 = 0 ;
31354 PyObject * obj6 = 0 ;
31355 char * kwnames[] = {
31356 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31357 };
31358
31359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31363 }
31364 arg1 = reinterpret_cast< wxWindow * >(argp1);
31365 ecode2 = SWIG_AsVal_int(obj1, &val2);
31366 if (!SWIG_IsOK(ecode2)) {
31367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31368 }
31369 arg2 = static_cast< int >(val2);
31370 ecode3 = SWIG_AsVal_int(obj2, &val3);
31371 if (!SWIG_IsOK(ecode3)) {
31372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31373 }
31374 arg3 = static_cast< int >(val3);
31375 if (obj3) {
31376 ecode4 = SWIG_AsVal_int(obj3, &val4);
31377 if (!SWIG_IsOK(ecode4)) {
31378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31379 }
31380 arg4 = static_cast< int >(val4);
31381 }
31382 if (obj4) {
31383 ecode5 = SWIG_AsVal_int(obj4, &val5);
31384 if (!SWIG_IsOK(ecode5)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31386 }
31387 arg5 = static_cast< int >(val5);
31388 }
31389 if (obj5) {
31390 ecode6 = SWIG_AsVal_int(obj5, &val6);
31391 if (!SWIG_IsOK(ecode6)) {
31392 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31393 }
31394 arg6 = static_cast< int >(val6);
31395 }
31396 if (obj6) {
31397 ecode7 = SWIG_AsVal_int(obj6, &val7);
31398 if (!SWIG_IsOK(ecode7)) {
31399 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31400 }
31401 arg7 = static_cast< int >(val7);
31402 }
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 resultobj = SWIG_Py_Void();
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj = 0;
31418 wxWindow *arg1 = (wxWindow *) 0 ;
31419 wxSize *arg2 = 0 ;
31420 wxSize const &arg3_defvalue = wxDefaultSize ;
31421 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31422 wxSize const &arg4_defvalue = wxDefaultSize ;
31423 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31424 void *argp1 = 0 ;
31425 int res1 = 0 ;
31426 wxSize temp2 ;
31427 wxSize temp3 ;
31428 wxSize temp4 ;
31429 PyObject * obj0 = 0 ;
31430 PyObject * obj1 = 0 ;
31431 PyObject * obj2 = 0 ;
31432 PyObject * obj3 = 0 ;
31433 char * kwnames[] = {
31434 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31435 };
31436
31437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31439 if (!SWIG_IsOK(res1)) {
31440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31441 }
31442 arg1 = reinterpret_cast< wxWindow * >(argp1);
31443 {
31444 arg2 = &temp2;
31445 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31446 }
31447 if (obj2) {
31448 {
31449 arg3 = &temp3;
31450 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31451 }
31452 }
31453 if (obj3) {
31454 {
31455 arg4 = &temp4;
31456 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31457 }
31458 }
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_Py_Void();
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31473 PyObject *resultobj = 0;
31474 wxWindow *arg1 = (wxWindow *) 0 ;
31475 int arg2 ;
31476 int arg3 ;
31477 int arg4 = (int) -1 ;
31478 int arg5 = (int) -1 ;
31479 void *argp1 = 0 ;
31480 int res1 = 0 ;
31481 int val2 ;
31482 int ecode2 = 0 ;
31483 int val3 ;
31484 int ecode3 = 0 ;
31485 int val4 ;
31486 int ecode4 = 0 ;
31487 int val5 ;
31488 int ecode5 = 0 ;
31489 PyObject * obj0 = 0 ;
31490 PyObject * obj1 = 0 ;
31491 PyObject * obj2 = 0 ;
31492 PyObject * obj3 = 0 ;
31493 PyObject * obj4 = 0 ;
31494 char * kwnames[] = {
31495 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31496 };
31497
31498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31500 if (!SWIG_IsOK(res1)) {
31501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31502 }
31503 arg1 = reinterpret_cast< wxWindow * >(argp1);
31504 ecode2 = SWIG_AsVal_int(obj1, &val2);
31505 if (!SWIG_IsOK(ecode2)) {
31506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31507 }
31508 arg2 = static_cast< int >(val2);
31509 ecode3 = SWIG_AsVal_int(obj2, &val3);
31510 if (!SWIG_IsOK(ecode3)) {
31511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31512 }
31513 arg3 = static_cast< int >(val3);
31514 if (obj3) {
31515 ecode4 = SWIG_AsVal_int(obj3, &val4);
31516 if (!SWIG_IsOK(ecode4)) {
31517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31518 }
31519 arg4 = static_cast< int >(val4);
31520 }
31521 if (obj4) {
31522 ecode5 = SWIG_AsVal_int(obj4, &val5);
31523 if (!SWIG_IsOK(ecode5)) {
31524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31525 }
31526 arg5 = static_cast< int >(val5);
31527 }
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_Py_Void();
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj = 0;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 wxSize *arg2 = 0 ;
31545 wxSize const &arg3_defvalue = wxDefaultSize ;
31546 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 wxSize temp2 ;
31550 wxSize temp3 ;
31551 PyObject * obj0 = 0 ;
31552 PyObject * obj1 = 0 ;
31553 PyObject * obj2 = 0 ;
31554 char * kwnames[] = {
31555 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31556 };
31557
31558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31560 if (!SWIG_IsOK(res1)) {
31561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31562 }
31563 arg1 = reinterpret_cast< wxWindow * >(argp1);
31564 {
31565 arg2 = &temp2;
31566 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31567 }
31568 if (obj2) {
31569 {
31570 arg3 = &temp3;
31571 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31572 }
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_Py_Void();
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 wxSize result;
31591 void *argp1 = 0 ;
31592 int res1 = 0 ;
31593 PyObject *swig_obj[1] ;
31594
31595 if (!args) SWIG_fail;
31596 swig_obj[0] = args;
31597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31598 if (!SWIG_IsOK(res1)) {
31599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31600 }
31601 arg1 = reinterpret_cast< wxWindow * >(argp1);
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = ((wxWindow const *)arg1)->GetMaxSize();
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31616 PyObject *resultobj = 0;
31617 wxWindow *arg1 = (wxWindow *) 0 ;
31618 wxSize result;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 PyObject *swig_obj[1] ;
31622
31623 if (!args) SWIG_fail;
31624 swig_obj[0] = args;
31625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31628 }
31629 arg1 = reinterpret_cast< wxWindow * >(argp1);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 result = ((wxWindow const *)arg1)->GetMinSize();
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31637 return resultobj;
31638 fail:
31639 return NULL;
31640 }
31641
31642
31643 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31644 PyObject *resultobj = 0;
31645 wxWindow *arg1 = (wxWindow *) 0 ;
31646 wxSize *arg2 = 0 ;
31647 void *argp1 = 0 ;
31648 int res1 = 0 ;
31649 wxSize temp2 ;
31650 PyObject * obj0 = 0 ;
31651 PyObject * obj1 = 0 ;
31652 char * kwnames[] = {
31653 (char *) "self",(char *) "minSize", NULL
31654 };
31655
31656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31660 }
31661 arg1 = reinterpret_cast< wxWindow * >(argp1);
31662 {
31663 arg2 = &temp2;
31664 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31665 }
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 (arg1)->SetMinSize((wxSize const &)*arg2);
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 resultobj = SWIG_Py_Void();
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj = 0;
31681 wxWindow *arg1 = (wxWindow *) 0 ;
31682 wxSize *arg2 = 0 ;
31683 void *argp1 = 0 ;
31684 int res1 = 0 ;
31685 wxSize temp2 ;
31686 PyObject * obj0 = 0 ;
31687 PyObject * obj1 = 0 ;
31688 char * kwnames[] = {
31689 (char *) "self",(char *) "maxSize", NULL
31690 };
31691
31692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31694 if (!SWIG_IsOK(res1)) {
31695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31696 }
31697 arg1 = reinterpret_cast< wxWindow * >(argp1);
31698 {
31699 arg2 = &temp2;
31700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31701 }
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 (arg1)->SetMaxSize((wxSize const &)*arg2);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_Py_Void();
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 int result;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 PyObject *swig_obj[1] ;
31722
31723 if (!args) SWIG_fail;
31724 swig_obj[0] = args;
31725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31726 if (!SWIG_IsOK(res1)) {
31727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31728 }
31729 arg1 = reinterpret_cast< wxWindow * >(argp1);
31730 {
31731 PyThreadState* __tstate = wxPyBeginAllowThreads();
31732 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 resultobj = SWIG_From_int(static_cast< int >(result));
31737 return resultobj;
31738 fail:
31739 return NULL;
31740 }
31741
31742
31743 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31744 PyObject *resultobj = 0;
31745 wxWindow *arg1 = (wxWindow *) 0 ;
31746 int result;
31747 void *argp1 = 0 ;
31748 int res1 = 0 ;
31749 PyObject *swig_obj[1] ;
31750
31751 if (!args) SWIG_fail;
31752 swig_obj[0] = args;
31753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31754 if (!SWIG_IsOK(res1)) {
31755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31756 }
31757 arg1 = reinterpret_cast< wxWindow * >(argp1);
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 resultobj = SWIG_From_int(static_cast< int >(result));
31765 return resultobj;
31766 fail:
31767 return NULL;
31768 }
31769
31770
31771 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31772 PyObject *resultobj = 0;
31773 wxWindow *arg1 = (wxWindow *) 0 ;
31774 int result;
31775 void *argp1 = 0 ;
31776 int res1 = 0 ;
31777 PyObject *swig_obj[1] ;
31778
31779 if (!args) SWIG_fail;
31780 swig_obj[0] = args;
31781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31782 if (!SWIG_IsOK(res1)) {
31783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31784 }
31785 arg1 = reinterpret_cast< wxWindow * >(argp1);
31786 {
31787 PyThreadState* __tstate = wxPyBeginAllowThreads();
31788 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31789 wxPyEndAllowThreads(__tstate);
31790 if (PyErr_Occurred()) SWIG_fail;
31791 }
31792 resultobj = SWIG_From_int(static_cast< int >(result));
31793 return resultobj;
31794 fail:
31795 return NULL;
31796 }
31797
31798
31799 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31800 PyObject *resultobj = 0;
31801 wxWindow *arg1 = (wxWindow *) 0 ;
31802 int result;
31803 void *argp1 = 0 ;
31804 int res1 = 0 ;
31805 PyObject *swig_obj[1] ;
31806
31807 if (!args) SWIG_fail;
31808 swig_obj[0] = args;
31809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31810 if (!SWIG_IsOK(res1)) {
31811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31812 }
31813 arg1 = reinterpret_cast< wxWindow * >(argp1);
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_From_int(static_cast< int >(result));
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31828 PyObject *resultobj = 0;
31829 wxWindow *arg1 = (wxWindow *) 0 ;
31830 wxSize *arg2 = 0 ;
31831 void *argp1 = 0 ;
31832 int res1 = 0 ;
31833 wxSize temp2 ;
31834 PyObject * obj0 = 0 ;
31835 PyObject * obj1 = 0 ;
31836 char * kwnames[] = {
31837 (char *) "self",(char *) "size", NULL
31838 };
31839
31840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31842 if (!SWIG_IsOK(res1)) {
31843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31844 }
31845 arg1 = reinterpret_cast< wxWindow * >(argp1);
31846 {
31847 arg2 = &temp2;
31848 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31849 }
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_Py_Void();
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = 0;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 int arg2 ;
31867 int arg3 ;
31868 void *argp1 = 0 ;
31869 int res1 = 0 ;
31870 int val2 ;
31871 int ecode2 = 0 ;
31872 int val3 ;
31873 int ecode3 = 0 ;
31874 PyObject * obj0 = 0 ;
31875 PyObject * obj1 = 0 ;
31876 PyObject * obj2 = 0 ;
31877 char * kwnames[] = {
31878 (char *) "self",(char *) "w",(char *) "h", NULL
31879 };
31880
31881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31883 if (!SWIG_IsOK(res1)) {
31884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31885 }
31886 arg1 = reinterpret_cast< wxWindow * >(argp1);
31887 ecode2 = SWIG_AsVal_int(obj1, &val2);
31888 if (!SWIG_IsOK(ecode2)) {
31889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31890 }
31891 arg2 = static_cast< int >(val2);
31892 ecode3 = SWIG_AsVal_int(obj2, &val3);
31893 if (!SWIG_IsOK(ecode3)) {
31894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31895 }
31896 arg3 = static_cast< int >(val3);
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 (arg1)->SetVirtualSize(arg2,arg3);
31900 wxPyEndAllowThreads(__tstate);
31901 if (PyErr_Occurred()) SWIG_fail;
31902 }
31903 resultobj = SWIG_Py_Void();
31904 return resultobj;
31905 fail:
31906 return NULL;
31907 }
31908
31909
31910 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31911 PyObject *resultobj = 0;
31912 wxWindow *arg1 = (wxWindow *) 0 ;
31913 wxSize result;
31914 void *argp1 = 0 ;
31915 int res1 = 0 ;
31916 PyObject *swig_obj[1] ;
31917
31918 if (!args) SWIG_fail;
31919 swig_obj[0] = args;
31920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31921 if (!SWIG_IsOK(res1)) {
31922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31923 }
31924 arg1 = reinterpret_cast< wxWindow * >(argp1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = ((wxWindow const *)arg1)->GetVirtualSize();
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 int *arg2 = (int *) 0 ;
31942 int *arg3 = (int *) 0 ;
31943 void *argp1 = 0 ;
31944 int res1 = 0 ;
31945 int temp2 ;
31946 int res2 = SWIG_TMPOBJ ;
31947 int temp3 ;
31948 int res3 = SWIG_TMPOBJ ;
31949 PyObject *swig_obj[1] ;
31950
31951 arg2 = &temp2;
31952 arg3 = &temp3;
31953 if (!args) SWIG_fail;
31954 swig_obj[0] = args;
31955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_Py_Void();
31967 if (SWIG_IsTmpObj(res2)) {
31968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31969 } else {
31970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31972 }
31973 if (SWIG_IsTmpObj(res3)) {
31974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31975 } else {
31976 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31978 }
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31986 PyObject *resultobj = 0;
31987 wxWindow *arg1 = (wxWindow *) 0 ;
31988 wxSize result;
31989 void *argp1 = 0 ;
31990 int res1 = 0 ;
31991 PyObject *swig_obj[1] ;
31992
31993 if (!args) SWIG_fail;
31994 swig_obj[0] = args;
31995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31996 if (!SWIG_IsOK(res1)) {
31997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31998 }
31999 arg1 = reinterpret_cast< wxWindow * >(argp1);
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32014 PyObject *resultobj = 0;
32015 wxWindow *arg1 = (wxWindow *) 0 ;
32016 bool arg2 = (bool) true ;
32017 bool result;
32018 void *argp1 = 0 ;
32019 int res1 = 0 ;
32020 bool val2 ;
32021 int ecode2 = 0 ;
32022 PyObject * obj0 = 0 ;
32023 PyObject * obj1 = 0 ;
32024 char * kwnames[] = {
32025 (char *) "self",(char *) "show", NULL
32026 };
32027
32028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32030 if (!SWIG_IsOK(res1)) {
32031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32032 }
32033 arg1 = reinterpret_cast< wxWindow * >(argp1);
32034 if (obj1) {
32035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32036 if (!SWIG_IsOK(ecode2)) {
32037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32038 }
32039 arg2 = static_cast< bool >(val2);
32040 }
32041 {
32042 PyThreadState* __tstate = wxPyBeginAllowThreads();
32043 result = (bool)(arg1)->Show(arg2);
32044 wxPyEndAllowThreads(__tstate);
32045 if (PyErr_Occurred()) SWIG_fail;
32046 }
32047 {
32048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32049 }
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 PyObject *resultobj = 0;
32058 wxWindow *arg1 = (wxWindow *) 0 ;
32059 bool result;
32060 void *argp1 = 0 ;
32061 int res1 = 0 ;
32062 PyObject *swig_obj[1] ;
32063
32064 if (!args) SWIG_fail;
32065 swig_obj[0] = args;
32066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32067 if (!SWIG_IsOK(res1)) {
32068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32069 }
32070 arg1 = reinterpret_cast< wxWindow * >(argp1);
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 result = (bool)(arg1)->Hide();
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 {
32078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32079 }
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = 0;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 bool arg2 = (bool) true ;
32090 bool result;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 bool val2 ;
32094 int ecode2 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "enable", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32105 }
32106 arg1 = reinterpret_cast< wxWindow * >(argp1);
32107 if (obj1) {
32108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32109 if (!SWIG_IsOK(ecode2)) {
32110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32111 }
32112 arg2 = static_cast< bool >(val2);
32113 }
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)(arg1)->Enable(arg2);
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 {
32121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32122 }
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32130 PyObject *resultobj = 0;
32131 wxWindow *arg1 = (wxWindow *) 0 ;
32132 bool result;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 PyObject *swig_obj[1] ;
32136
32137 if (!args) SWIG_fail;
32138 swig_obj[0] = args;
32139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32140 if (!SWIG_IsOK(res1)) {
32141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32142 }
32143 arg1 = reinterpret_cast< wxWindow * >(argp1);
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 result = (bool)(arg1)->Disable();
32147 wxPyEndAllowThreads(__tstate);
32148 if (PyErr_Occurred()) SWIG_fail;
32149 }
32150 {
32151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32152 }
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 bool result;
32163 void *argp1 = 0 ;
32164 int res1 = 0 ;
32165 PyObject *swig_obj[1] ;
32166
32167 if (!args) SWIG_fail;
32168 swig_obj[0] = args;
32169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32170 if (!SWIG_IsOK(res1)) {
32171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 {
32175 PyThreadState* __tstate = wxPyBeginAllowThreads();
32176 result = (bool)((wxWindow const *)arg1)->IsShown();
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 {
32181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32182 }
32183 return resultobj;
32184 fail:
32185 return NULL;
32186 }
32187
32188
32189 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32190 PyObject *resultobj = 0;
32191 wxWindow *arg1 = (wxWindow *) 0 ;
32192 bool result;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 PyObject *swig_obj[1] ;
32196
32197 if (!args) SWIG_fail;
32198 swig_obj[0] = args;
32199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32200 if (!SWIG_IsOK(res1)) {
32201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32202 }
32203 arg1 = reinterpret_cast< wxWindow * >(argp1);
32204 {
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32207 wxPyEndAllowThreads(__tstate);
32208 if (PyErr_Occurred()) SWIG_fail;
32209 }
32210 {
32211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32212 }
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 long arg2 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 long val2 ;
32226 int ecode2 = 0 ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char * kwnames[] = {
32230 (char *) "self",(char *) "style", NULL
32231 };
32232
32233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32235 if (!SWIG_IsOK(res1)) {
32236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32237 }
32238 arg1 = reinterpret_cast< wxWindow * >(argp1);
32239 ecode2 = SWIG_AsVal_long(obj1, &val2);
32240 if (!SWIG_IsOK(ecode2)) {
32241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32242 }
32243 arg2 = static_cast< long >(val2);
32244 {
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 (arg1)->SetWindowStyleFlag(arg2);
32247 wxPyEndAllowThreads(__tstate);
32248 if (PyErr_Occurred()) SWIG_fail;
32249 }
32250 resultobj = SWIG_Py_Void();
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32258 PyObject *resultobj = 0;
32259 wxWindow *arg1 = (wxWindow *) 0 ;
32260 long result;
32261 void *argp1 = 0 ;
32262 int res1 = 0 ;
32263 PyObject *swig_obj[1] ;
32264
32265 if (!args) SWIG_fail;
32266 swig_obj[0] = args;
32267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32268 if (!SWIG_IsOK(res1)) {
32269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32270 }
32271 arg1 = reinterpret_cast< wxWindow * >(argp1);
32272 {
32273 PyThreadState* __tstate = wxPyBeginAllowThreads();
32274 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32275 wxPyEndAllowThreads(__tstate);
32276 if (PyErr_Occurred()) SWIG_fail;
32277 }
32278 resultobj = SWIG_From_long(static_cast< long >(result));
32279 return resultobj;
32280 fail:
32281 return NULL;
32282 }
32283
32284
32285 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32286 PyObject *resultobj = 0;
32287 wxWindow *arg1 = (wxWindow *) 0 ;
32288 int arg2 ;
32289 bool result;
32290 void *argp1 = 0 ;
32291 int res1 = 0 ;
32292 int val2 ;
32293 int ecode2 = 0 ;
32294 PyObject * obj0 = 0 ;
32295 PyObject * obj1 = 0 ;
32296 char * kwnames[] = {
32297 (char *) "self",(char *) "flag", NULL
32298 };
32299
32300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32302 if (!SWIG_IsOK(res1)) {
32303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32304 }
32305 arg1 = reinterpret_cast< wxWindow * >(argp1);
32306 ecode2 = SWIG_AsVal_int(obj1, &val2);
32307 if (!SWIG_IsOK(ecode2)) {
32308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32309 }
32310 arg2 = static_cast< int >(val2);
32311 {
32312 PyThreadState* __tstate = wxPyBeginAllowThreads();
32313 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 {
32318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32319 }
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32327 PyObject *resultobj = 0;
32328 wxWindow *arg1 = (wxWindow *) 0 ;
32329 bool result;
32330 void *argp1 = 0 ;
32331 int res1 = 0 ;
32332 PyObject *swig_obj[1] ;
32333
32334 if (!args) SWIG_fail;
32335 swig_obj[0] = args;
32336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32337 if (!SWIG_IsOK(res1)) {
32338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32339 }
32340 arg1 = reinterpret_cast< wxWindow * >(argp1);
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 result = (bool)((wxWindow const *)arg1)->IsRetained();
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 {
32348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32349 }
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj = 0;
32358 wxWindow *arg1 = (wxWindow *) 0 ;
32359 long arg2 ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 long val2 ;
32363 int ecode2 = 0 ;
32364 PyObject * obj0 = 0 ;
32365 PyObject * obj1 = 0 ;
32366 char * kwnames[] = {
32367 (char *) "self",(char *) "exStyle", NULL
32368 };
32369
32370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32374 }
32375 arg1 = reinterpret_cast< wxWindow * >(argp1);
32376 ecode2 = SWIG_AsVal_long(obj1, &val2);
32377 if (!SWIG_IsOK(ecode2)) {
32378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32379 }
32380 arg2 = static_cast< long >(val2);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 (arg1)->SetExtraStyle(arg2);
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_Py_Void();
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 long result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32407 }
32408 arg1 = reinterpret_cast< wxWindow * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 resultobj = SWIG_From_long(static_cast< long >(result));
32416 return resultobj;
32417 fail:
32418 return NULL;
32419 }
32420
32421
32422 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32423 PyObject *resultobj = 0;
32424 wxWindow *arg1 = (wxWindow *) 0 ;
32425 bool arg2 = (bool) true ;
32426 void *argp1 = 0 ;
32427 int res1 = 0 ;
32428 bool val2 ;
32429 int ecode2 = 0 ;
32430 PyObject * obj0 = 0 ;
32431 PyObject * obj1 = 0 ;
32432 char * kwnames[] = {
32433 (char *) "self",(char *) "modal", NULL
32434 };
32435
32436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32440 }
32441 arg1 = reinterpret_cast< wxWindow * >(argp1);
32442 if (obj1) {
32443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32444 if (!SWIG_IsOK(ecode2)) {
32445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32446 }
32447 arg2 = static_cast< bool >(val2);
32448 }
32449 {
32450 PyThreadState* __tstate = wxPyBeginAllowThreads();
32451 (arg1)->MakeModal(arg2);
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 resultobj = SWIG_Py_Void();
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj = 0;
32464 wxWindow *arg1 = (wxWindow *) 0 ;
32465 bool arg2 ;
32466 void *argp1 = 0 ;
32467 int res1 = 0 ;
32468 bool val2 ;
32469 int ecode2 = 0 ;
32470 PyObject * obj0 = 0 ;
32471 PyObject * obj1 = 0 ;
32472 char * kwnames[] = {
32473 (char *) "self",(char *) "enableTheme", NULL
32474 };
32475
32476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32480 }
32481 arg1 = reinterpret_cast< wxWindow * >(argp1);
32482 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32483 if (!SWIG_IsOK(ecode2)) {
32484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32485 }
32486 arg2 = static_cast< bool >(val2);
32487 {
32488 PyThreadState* __tstate = wxPyBeginAllowThreads();
32489 (arg1)->SetThemeEnabled(arg2);
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 resultobj = SWIG_Py_Void();
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 bool result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxWindow *arg1 = (wxWindow *) 0 ;
32533 void *argp1 = 0 ;
32534 int res1 = 0 ;
32535 PyObject *swig_obj[1] ;
32536
32537 if (!args) SWIG_fail;
32538 swig_obj[0] = args;
32539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32540 if (!SWIG_IsOK(res1)) {
32541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32542 }
32543 arg1 = reinterpret_cast< wxWindow * >(argp1);
32544 {
32545 PyThreadState* __tstate = wxPyBeginAllowThreads();
32546 (arg1)->SetFocus();
32547 wxPyEndAllowThreads(__tstate);
32548 if (PyErr_Occurred()) SWIG_fail;
32549 }
32550 resultobj = SWIG_Py_Void();
32551 return resultobj;
32552 fail:
32553 return NULL;
32554 }
32555
32556
32557 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32558 PyObject *resultobj = 0;
32559 wxWindow *arg1 = (wxWindow *) 0 ;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 PyObject *swig_obj[1] ;
32563
32564 if (!args) SWIG_fail;
32565 swig_obj[0] = args;
32566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 (arg1)->SetFocusFromKbd();
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 PyObject *resultobj = 0;
32586 wxWindow *result = 0 ;
32587
32588 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32589 {
32590 if (!wxPyCheckForApp()) SWIG_fail;
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (wxWindow *)wxWindow::FindFocus();
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 {
32597 resultobj = wxPyMake_wxObject(result, 0);
32598 }
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32606 PyObject *resultobj = 0;
32607 wxWindow *arg1 = (wxWindow *) 0 ;
32608 bool result;
32609 void *argp1 = 0 ;
32610 int res1 = 0 ;
32611 PyObject *swig_obj[1] ;
32612
32613 if (!args) SWIG_fail;
32614 swig_obj[0] = args;
32615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32618 }
32619 arg1 = reinterpret_cast< wxWindow * >(argp1);
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 {
32627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32628 }
32629 return resultobj;
32630 fail:
32631 return NULL;
32632 }
32633
32634
32635 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32636 PyObject *resultobj = 0;
32637 wxWindow *arg1 = (wxWindow *) 0 ;
32638 bool result;
32639 void *argp1 = 0 ;
32640 int res1 = 0 ;
32641 PyObject *swig_obj[1] ;
32642
32643 if (!args) SWIG_fail;
32644 swig_obj[0] = args;
32645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32646 if (!SWIG_IsOK(res1)) {
32647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32648 }
32649 arg1 = reinterpret_cast< wxWindow * >(argp1);
32650 {
32651 PyThreadState* __tstate = wxPyBeginAllowThreads();
32652 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32653 wxPyEndAllowThreads(__tstate);
32654 if (PyErr_Occurred()) SWIG_fail;
32655 }
32656 {
32657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32658 }
32659 return resultobj;
32660 fail:
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32666 PyObject *resultobj = 0;
32667 wxWindow *arg1 = (wxWindow *) 0 ;
32668 wxWindow *result = 0 ;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 PyObject *swig_obj[1] ;
32672
32673 if (!args) SWIG_fail;
32674 swig_obj[0] = args;
32675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32678 }
32679 arg1 = reinterpret_cast< wxWindow * >(argp1);
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 {
32687 resultobj = wxPyMake_wxObject(result, 0);
32688 }
32689 return resultobj;
32690 fail:
32691 return NULL;
32692 }
32693
32694
32695 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj = 0;
32697 wxWindow *arg1 = (wxWindow *) 0 ;
32698 wxWindow *arg2 = (wxWindow *) 0 ;
32699 wxWindow *result = 0 ;
32700 void *argp1 = 0 ;
32701 int res1 = 0 ;
32702 void *argp2 = 0 ;
32703 int res2 = 0 ;
32704 PyObject * obj0 = 0 ;
32705 PyObject * obj1 = 0 ;
32706 char * kwnames[] = {
32707 (char *) "self",(char *) "child", NULL
32708 };
32709
32710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32712 if (!SWIG_IsOK(res1)) {
32713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32714 }
32715 arg1 = reinterpret_cast< wxWindow * >(argp1);
32716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32717 if (!SWIG_IsOK(res2)) {
32718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32719 }
32720 arg2 = reinterpret_cast< wxWindow * >(argp2);
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 {
32728 resultobj = wxPyMake_wxObject(result, 0);
32729 }
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32737 PyObject *resultobj = 0;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 wxWindow *arg2 = (wxWindow *) 0 ;
32740 void *argp1 = 0 ;
32741 int res1 = 0 ;
32742 void *argp2 = 0 ;
32743 int res2 = 0 ;
32744 PyObject * obj0 = 0 ;
32745 PyObject * obj1 = 0 ;
32746 char * kwnames[] = {
32747 (char *) "self",(char *) "win", NULL
32748 };
32749
32750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32754 }
32755 arg1 = reinterpret_cast< wxWindow * >(argp1);
32756 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32757 if (!SWIG_IsOK(res2)) {
32758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32759 }
32760 arg2 = reinterpret_cast< wxWindow * >(argp2);
32761 {
32762 PyThreadState* __tstate = wxPyBeginAllowThreads();
32763 (arg1)->SetTmpDefaultItem(arg2);
32764 wxPyEndAllowThreads(__tstate);
32765 if (PyErr_Occurred()) SWIG_fail;
32766 }
32767 resultobj = SWIG_Py_Void();
32768 return resultobj;
32769 fail:
32770 return NULL;
32771 }
32772
32773
32774 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32775 PyObject *resultobj = 0;
32776 wxWindow *arg1 = (wxWindow *) 0 ;
32777 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32778 bool result;
32779 void *argp1 = 0 ;
32780 int res1 = 0 ;
32781 int val2 ;
32782 int ecode2 = 0 ;
32783 PyObject * obj0 = 0 ;
32784 PyObject * obj1 = 0 ;
32785 char * kwnames[] = {
32786 (char *) "self",(char *) "flags", NULL
32787 };
32788
32789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32791 if (!SWIG_IsOK(res1)) {
32792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32793 }
32794 arg1 = reinterpret_cast< wxWindow * >(argp1);
32795 if (obj1) {
32796 ecode2 = SWIG_AsVal_int(obj1, &val2);
32797 if (!SWIG_IsOK(ecode2)) {
32798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32799 }
32800 arg2 = static_cast< int >(val2);
32801 }
32802 {
32803 PyThreadState* __tstate = wxPyBeginAllowThreads();
32804 result = (bool)(arg1)->Navigate(arg2);
32805 wxPyEndAllowThreads(__tstate);
32806 if (PyErr_Occurred()) SWIG_fail;
32807 }
32808 {
32809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32810 }
32811 return resultobj;
32812 fail:
32813 return NULL;
32814 }
32815
32816
32817 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj = 0;
32819 wxWindow *arg1 = (wxWindow *) 0 ;
32820 wxWindow *arg2 = (wxWindow *) 0 ;
32821 void *argp1 = 0 ;
32822 int res1 = 0 ;
32823 void *argp2 = 0 ;
32824 int res2 = 0 ;
32825 PyObject * obj0 = 0 ;
32826 PyObject * obj1 = 0 ;
32827 char * kwnames[] = {
32828 (char *) "self",(char *) "win", NULL
32829 };
32830
32831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res2)) {
32839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32840 }
32841 arg2 = reinterpret_cast< wxWindow * >(argp2);
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 (arg1)->MoveAfterInTabOrder(arg2);
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 resultobj = SWIG_Py_Void();
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32856 PyObject *resultobj = 0;
32857 wxWindow *arg1 = (wxWindow *) 0 ;
32858 wxWindow *arg2 = (wxWindow *) 0 ;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 void *argp2 = 0 ;
32862 int res2 = 0 ;
32863 PyObject * obj0 = 0 ;
32864 PyObject * obj1 = 0 ;
32865 char * kwnames[] = {
32866 (char *) "self",(char *) "win", NULL
32867 };
32868
32869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32873 }
32874 arg1 = reinterpret_cast< wxWindow * >(argp1);
32875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32876 if (!SWIG_IsOK(res2)) {
32877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32878 }
32879 arg2 = reinterpret_cast< wxWindow * >(argp2);
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 (arg1)->MoveBeforeInTabOrder(arg2);
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 resultobj = SWIG_Py_Void();
32887 return resultobj;
32888 fail:
32889 return NULL;
32890 }
32891
32892
32893 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32894 PyObject *resultobj = 0;
32895 wxWindow *arg1 = (wxWindow *) 0 ;
32896 PyObject *result = 0 ;
32897 void *argp1 = 0 ;
32898 int res1 = 0 ;
32899 PyObject *swig_obj[1] ;
32900
32901 if (!args) SWIG_fail;
32902 swig_obj[0] = args;
32903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32904 if (!SWIG_IsOK(res1)) {
32905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32906 }
32907 arg1 = reinterpret_cast< wxWindow * >(argp1);
32908 {
32909 PyThreadState* __tstate = wxPyBeginAllowThreads();
32910 result = (PyObject *)wxWindow_GetChildren(arg1);
32911 wxPyEndAllowThreads(__tstate);
32912 if (PyErr_Occurred()) SWIG_fail;
32913 }
32914 resultobj = result;
32915 return resultobj;
32916 fail:
32917 return NULL;
32918 }
32919
32920
32921 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32922 PyObject *resultobj = 0;
32923 wxWindow *arg1 = (wxWindow *) 0 ;
32924 wxWindow *result = 0 ;
32925 void *argp1 = 0 ;
32926 int res1 = 0 ;
32927 PyObject *swig_obj[1] ;
32928
32929 if (!args) SWIG_fail;
32930 swig_obj[0] = args;
32931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res1)) {
32933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32934 }
32935 arg1 = reinterpret_cast< wxWindow * >(argp1);
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 {
32943 resultobj = wxPyMake_wxObject(result, 0);
32944 }
32945 return resultobj;
32946 fail:
32947 return NULL;
32948 }
32949
32950
32951 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32952 PyObject *resultobj = 0;
32953 wxWindow *arg1 = (wxWindow *) 0 ;
32954 wxWindow *result = 0 ;
32955 void *argp1 = 0 ;
32956 int res1 = 0 ;
32957 PyObject *swig_obj[1] ;
32958
32959 if (!args) SWIG_fail;
32960 swig_obj[0] = args;
32961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32964 }
32965 arg1 = reinterpret_cast< wxWindow * >(argp1);
32966 {
32967 PyThreadState* __tstate = wxPyBeginAllowThreads();
32968 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32969 wxPyEndAllowThreads(__tstate);
32970 if (PyErr_Occurred()) SWIG_fail;
32971 }
32972 {
32973 resultobj = wxPyMake_wxObject(result, 0);
32974 }
32975 return resultobj;
32976 fail:
32977 return NULL;
32978 }
32979
32980
32981 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32982 PyObject *resultobj = 0;
32983 wxWindow *arg1 = (wxWindow *) 0 ;
32984 bool result;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 PyObject *swig_obj[1] ;
32988
32989 if (!args) SWIG_fail;
32990 swig_obj[0] = args;
32991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32992 if (!SWIG_IsOK(res1)) {
32993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32994 }
32995 arg1 = reinterpret_cast< wxWindow * >(argp1);
32996 {
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33004 }
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj = 0;
33013 wxWindow *arg1 = (wxWindow *) 0 ;
33014 wxWindow *arg2 = (wxWindow *) 0 ;
33015 bool result;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 void *argp2 = 0 ;
33019 int res2 = 0 ;
33020 PyObject * obj0 = 0 ;
33021 PyObject * obj1 = 0 ;
33022 char * kwnames[] = {
33023 (char *) "self",(char *) "newParent", NULL
33024 };
33025
33026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33028 if (!SWIG_IsOK(res1)) {
33029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33030 }
33031 arg1 = reinterpret_cast< wxWindow * >(argp1);
33032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res2)) {
33034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33035 }
33036 arg2 = reinterpret_cast< wxWindow * >(argp2);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (bool)(arg1)->Reparent(arg2);
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 wxWindow *arg2 = (wxWindow *) 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 void *argp2 = 0 ;
33059 int res2 = 0 ;
33060 PyObject * obj0 = 0 ;
33061 PyObject * obj1 = 0 ;
33062 char * kwnames[] = {
33063 (char *) "self",(char *) "child", NULL
33064 };
33065
33066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33068 if (!SWIG_IsOK(res1)) {
33069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33070 }
33071 arg1 = reinterpret_cast< wxWindow * >(argp1);
33072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33073 if (!SWIG_IsOK(res2)) {
33074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33075 }
33076 arg2 = reinterpret_cast< wxWindow * >(argp2);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 (arg1)->AddChild(arg2);
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 resultobj = SWIG_Py_Void();
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj = 0;
33092 wxWindow *arg1 = (wxWindow *) 0 ;
33093 wxWindow *arg2 = (wxWindow *) 0 ;
33094 void *argp1 = 0 ;
33095 int res1 = 0 ;
33096 void *argp2 = 0 ;
33097 int res2 = 0 ;
33098 PyObject * obj0 = 0 ;
33099 PyObject * obj1 = 0 ;
33100 char * kwnames[] = {
33101 (char *) "self",(char *) "child", NULL
33102 };
33103
33104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33111 if (!SWIG_IsOK(res2)) {
33112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33113 }
33114 arg2 = reinterpret_cast< wxWindow * >(argp2);
33115 {
33116 PyThreadState* __tstate = wxPyBeginAllowThreads();
33117 (arg1)->RemoveChild(arg2);
33118 wxPyEndAllowThreads(__tstate);
33119 if (PyErr_Occurred()) SWIG_fail;
33120 }
33121 resultobj = SWIG_Py_Void();
33122 return resultobj;
33123 fail:
33124 return NULL;
33125 }
33126
33127
33128 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33129 PyObject *resultobj = 0;
33130 wxWindow *arg1 = (wxWindow *) 0 ;
33131 long arg2 ;
33132 wxWindow *result = 0 ;
33133 void *argp1 = 0 ;
33134 int res1 = 0 ;
33135 long val2 ;
33136 int ecode2 = 0 ;
33137 PyObject * obj0 = 0 ;
33138 PyObject * obj1 = 0 ;
33139 char * kwnames[] = {
33140 (char *) "self",(char *) "winid", NULL
33141 };
33142
33143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33147 }
33148 arg1 = reinterpret_cast< wxWindow * >(argp1);
33149 ecode2 = SWIG_AsVal_long(obj1, &val2);
33150 if (!SWIG_IsOK(ecode2)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33152 }
33153 arg2 = static_cast< long >(val2);
33154 {
33155 PyThreadState* __tstate = wxPyBeginAllowThreads();
33156 result = (wxWindow *)(arg1)->FindWindow(arg2);
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 {
33161 resultobj = wxPyMake_wxObject(result, 0);
33162 }
33163 return resultobj;
33164 fail:
33165 return NULL;
33166 }
33167
33168
33169 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33170 PyObject *resultobj = 0;
33171 wxWindow *arg1 = (wxWindow *) 0 ;
33172 wxString *arg2 = 0 ;
33173 wxWindow *result = 0 ;
33174 void *argp1 = 0 ;
33175 int res1 = 0 ;
33176 bool temp2 = false ;
33177 PyObject * obj0 = 0 ;
33178 PyObject * obj1 = 0 ;
33179 char * kwnames[] = {
33180 (char *) "self",(char *) "name", NULL
33181 };
33182
33183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33185 if (!SWIG_IsOK(res1)) {
33186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33187 }
33188 arg1 = reinterpret_cast< wxWindow * >(argp1);
33189 {
33190 arg2 = wxString_in_helper(obj1);
33191 if (arg2 == NULL) SWIG_fail;
33192 temp2 = true;
33193 }
33194 {
33195 PyThreadState* __tstate = wxPyBeginAllowThreads();
33196 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 {
33201 resultobj = wxPyMake_wxObject(result, 0);
33202 }
33203 {
33204 if (temp2)
33205 delete arg2;
33206 }
33207 return resultobj;
33208 fail:
33209 {
33210 if (temp2)
33211 delete arg2;
33212 }
33213 return NULL;
33214 }
33215
33216
33217 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33218 PyObject *resultobj = 0;
33219 wxWindow *arg1 = (wxWindow *) 0 ;
33220 wxEvtHandler *result = 0 ;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 PyObject *swig_obj[1] ;
33224
33225 if (!args) SWIG_fail;
33226 swig_obj[0] = args;
33227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33230 }
33231 arg1 = reinterpret_cast< wxWindow * >(argp1);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 {
33239 resultobj = wxPyMake_wxObject(result, 0);
33240 }
33241 return resultobj;
33242 fail:
33243 return NULL;
33244 }
33245
33246
33247 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33248 PyObject *resultobj = 0;
33249 wxWindow *arg1 = (wxWindow *) 0 ;
33250 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33251 void *argp1 = 0 ;
33252 int res1 = 0 ;
33253 void *argp2 = 0 ;
33254 int res2 = 0 ;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 char * kwnames[] = {
33258 (char *) "self",(char *) "handler", NULL
33259 };
33260
33261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33263 if (!SWIG_IsOK(res1)) {
33264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33265 }
33266 arg1 = reinterpret_cast< wxWindow * >(argp1);
33267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33268 if (!SWIG_IsOK(res2)) {
33269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33270 }
33271 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 (arg1)->SetEventHandler(arg2);
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 resultobj = SWIG_Py_Void();
33279 return resultobj;
33280 fail:
33281 return NULL;
33282 }
33283
33284
33285 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33286 PyObject *resultobj = 0;
33287 wxWindow *arg1 = (wxWindow *) 0 ;
33288 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33289 void *argp1 = 0 ;
33290 int res1 = 0 ;
33291 void *argp2 = 0 ;
33292 int res2 = 0 ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 char * kwnames[] = {
33296 (char *) "self",(char *) "handler", NULL
33297 };
33298
33299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33303 }
33304 arg1 = reinterpret_cast< wxWindow * >(argp1);
33305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33306 if (!SWIG_IsOK(res2)) {
33307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33308 }
33309 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33310 {
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 (arg1)->PushEventHandler(arg2);
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 resultobj = SWIG_Py_Void();
33317 return resultobj;
33318 fail:
33319 return NULL;
33320 }
33321
33322
33323 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33324 PyObject *resultobj = 0;
33325 wxWindow *arg1 = (wxWindow *) 0 ;
33326 bool arg2 = (bool) false ;
33327 wxEvtHandler *result = 0 ;
33328 void *argp1 = 0 ;
33329 int res1 = 0 ;
33330 bool val2 ;
33331 int ecode2 = 0 ;
33332 PyObject * obj0 = 0 ;
33333 PyObject * obj1 = 0 ;
33334 char * kwnames[] = {
33335 (char *) "self",(char *) "deleteHandler", NULL
33336 };
33337
33338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33340 if (!SWIG_IsOK(res1)) {
33341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33342 }
33343 arg1 = reinterpret_cast< wxWindow * >(argp1);
33344 if (obj1) {
33345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33346 if (!SWIG_IsOK(ecode2)) {
33347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33348 }
33349 arg2 = static_cast< bool >(val2);
33350 }
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 {
33358 resultobj = wxPyMake_wxObject(result, 0);
33359 }
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj = 0;
33368 wxWindow *arg1 = (wxWindow *) 0 ;
33369 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33370 bool result;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 void *argp2 = 0 ;
33374 int res2 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "self",(char *) "handler", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33388 if (!SWIG_IsOK(res2)) {
33389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33390 }
33391 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 result = (bool)(arg1)->RemoveEventHandler(arg2);
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 {
33399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33400 }
33401 return resultobj;
33402 fail:
33403 return NULL;
33404 }
33405
33406
33407 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33408 PyObject *resultobj = 0;
33409 wxWindow *arg1 = (wxWindow *) 0 ;
33410 wxValidator *arg2 = 0 ;
33411 void *argp1 = 0 ;
33412 int res1 = 0 ;
33413 void *argp2 = 0 ;
33414 int res2 = 0 ;
33415 PyObject * obj0 = 0 ;
33416 PyObject * obj1 = 0 ;
33417 char * kwnames[] = {
33418 (char *) "self",(char *) "validator", NULL
33419 };
33420
33421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33425 }
33426 arg1 = reinterpret_cast< wxWindow * >(argp1);
33427 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33428 if (!SWIG_IsOK(res2)) {
33429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33430 }
33431 if (!argp2) {
33432 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33433 }
33434 arg2 = reinterpret_cast< wxValidator * >(argp2);
33435 {
33436 PyThreadState* __tstate = wxPyBeginAllowThreads();
33437 (arg1)->SetValidator((wxValidator const &)*arg2);
33438 wxPyEndAllowThreads(__tstate);
33439 if (PyErr_Occurred()) SWIG_fail;
33440 }
33441 resultobj = SWIG_Py_Void();
33442 return resultobj;
33443 fail:
33444 return NULL;
33445 }
33446
33447
33448 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33449 PyObject *resultobj = 0;
33450 wxWindow *arg1 = (wxWindow *) 0 ;
33451 wxValidator *result = 0 ;
33452 void *argp1 = 0 ;
33453 int res1 = 0 ;
33454 PyObject *swig_obj[1] ;
33455
33456 if (!args) SWIG_fail;
33457 swig_obj[0] = args;
33458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33459 if (!SWIG_IsOK(res1)) {
33460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33461 }
33462 arg1 = reinterpret_cast< wxWindow * >(argp1);
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 result = (wxValidator *)(arg1)->GetValidator();
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 {
33470 resultobj = wxPyMake_wxObject(result, (bool)0);
33471 }
33472 return resultobj;
33473 fail:
33474 return NULL;
33475 }
33476
33477
33478 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33479 PyObject *resultobj = 0;
33480 wxWindow *arg1 = (wxWindow *) 0 ;
33481 bool result;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 PyObject *swig_obj[1] ;
33485
33486 if (!args) SWIG_fail;
33487 swig_obj[0] = args;
33488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33489 if (!SWIG_IsOK(res1)) {
33490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33491 }
33492 arg1 = reinterpret_cast< wxWindow * >(argp1);
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 result = (bool)(arg1)->Validate();
33496 wxPyEndAllowThreads(__tstate);
33497 if (PyErr_Occurred()) SWIG_fail;
33498 }
33499 {
33500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33501 }
33502 return resultobj;
33503 fail:
33504 return NULL;
33505 }
33506
33507
33508 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33509 PyObject *resultobj = 0;
33510 wxWindow *arg1 = (wxWindow *) 0 ;
33511 bool result;
33512 void *argp1 = 0 ;
33513 int res1 = 0 ;
33514 PyObject *swig_obj[1] ;
33515
33516 if (!args) SWIG_fail;
33517 swig_obj[0] = args;
33518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res1)) {
33520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33521 }
33522 arg1 = reinterpret_cast< wxWindow * >(argp1);
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 result = (bool)(arg1)->TransferDataToWindow();
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 {
33530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33531 }
33532 return resultobj;
33533 fail:
33534 return NULL;
33535 }
33536
33537
33538 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33539 PyObject *resultobj = 0;
33540 wxWindow *arg1 = (wxWindow *) 0 ;
33541 bool result;
33542 void *argp1 = 0 ;
33543 int res1 = 0 ;
33544 PyObject *swig_obj[1] ;
33545
33546 if (!args) SWIG_fail;
33547 swig_obj[0] = args;
33548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33549 if (!SWIG_IsOK(res1)) {
33550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33551 }
33552 arg1 = reinterpret_cast< wxWindow * >(argp1);
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 result = (bool)(arg1)->TransferDataFromWindow();
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 {
33560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33561 }
33562 return resultobj;
33563 fail:
33564 return NULL;
33565 }
33566
33567
33568 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 PyObject *resultobj = 0;
33570 wxWindow *arg1 = (wxWindow *) 0 ;
33571 void *argp1 = 0 ;
33572 int res1 = 0 ;
33573 PyObject *swig_obj[1] ;
33574
33575 if (!args) SWIG_fail;
33576 swig_obj[0] = args;
33577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res1)) {
33579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33580 }
33581 arg1 = reinterpret_cast< wxWindow * >(argp1);
33582 {
33583 PyThreadState* __tstate = wxPyBeginAllowThreads();
33584 (arg1)->InitDialog();
33585 wxPyEndAllowThreads(__tstate);
33586 if (PyErr_Occurred()) SWIG_fail;
33587 }
33588 resultobj = SWIG_Py_Void();
33589 return resultobj;
33590 fail:
33591 return NULL;
33592 }
33593
33594
33595 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33596 PyObject *resultobj = 0;
33597 wxWindow *arg1 = (wxWindow *) 0 ;
33598 wxAcceleratorTable *arg2 = 0 ;
33599 void *argp1 = 0 ;
33600 int res1 = 0 ;
33601 void *argp2 = 0 ;
33602 int res2 = 0 ;
33603 PyObject * obj0 = 0 ;
33604 PyObject * obj1 = 0 ;
33605 char * kwnames[] = {
33606 (char *) "self",(char *) "accel", NULL
33607 };
33608
33609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33611 if (!SWIG_IsOK(res1)) {
33612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33613 }
33614 arg1 = reinterpret_cast< wxWindow * >(argp1);
33615 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33616 if (!SWIG_IsOK(res2)) {
33617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33618 }
33619 if (!argp2) {
33620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33621 }
33622 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33626 wxPyEndAllowThreads(__tstate);
33627 if (PyErr_Occurred()) SWIG_fail;
33628 }
33629 resultobj = SWIG_Py_Void();
33630 return resultobj;
33631 fail:
33632 return NULL;
33633 }
33634
33635
33636 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33637 PyObject *resultobj = 0;
33638 wxWindow *arg1 = (wxWindow *) 0 ;
33639 wxAcceleratorTable *result = 0 ;
33640 void *argp1 = 0 ;
33641 int res1 = 0 ;
33642 PyObject *swig_obj[1] ;
33643
33644 if (!args) SWIG_fail;
33645 swig_obj[0] = args;
33646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33647 if (!SWIG_IsOK(res1)) {
33648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33649 }
33650 arg1 = reinterpret_cast< wxWindow * >(argp1);
33651 {
33652 PyThreadState* __tstate = wxPyBeginAllowThreads();
33653 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33654 wxPyEndAllowThreads(__tstate);
33655 if (PyErr_Occurred()) SWIG_fail;
33656 }
33657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33658 return resultobj;
33659 fail:
33660 return NULL;
33661 }
33662
33663
33664 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33665 PyObject *resultobj = 0;
33666 wxWindow *arg1 = (wxWindow *) 0 ;
33667 int arg2 ;
33668 int arg3 ;
33669 int arg4 ;
33670 bool result;
33671 void *argp1 = 0 ;
33672 int res1 = 0 ;
33673 int val2 ;
33674 int ecode2 = 0 ;
33675 int val3 ;
33676 int ecode3 = 0 ;
33677 int val4 ;
33678 int ecode4 = 0 ;
33679 PyObject * obj0 = 0 ;
33680 PyObject * obj1 = 0 ;
33681 PyObject * obj2 = 0 ;
33682 PyObject * obj3 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 ecode2 = SWIG_AsVal_int(obj1, &val2);
33694 if (!SWIG_IsOK(ecode2)) {
33695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33696 }
33697 arg2 = static_cast< int >(val2);
33698 ecode3 = SWIG_AsVal_int(obj2, &val3);
33699 if (!SWIG_IsOK(ecode3)) {
33700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33701 }
33702 arg3 = static_cast< int >(val3);
33703 ecode4 = SWIG_AsVal_int(obj3, &val4);
33704 if (!SWIG_IsOK(ecode4)) {
33705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33706 }
33707 arg4 = static_cast< int >(val4);
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 {
33715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33716 }
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 int arg2 ;
33727 bool result;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 int val2 ;
33731 int ecode2 = 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "hotkeyId", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 ecode2 = SWIG_AsVal_int(obj1, &val2);
33745 if (!SWIG_IsOK(ecode2)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33747 }
33748 arg2 = static_cast< int >(val2);
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 {
33756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33757 }
33758 return resultobj;
33759 fail:
33760 return NULL;
33761 }
33762
33763
33764 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33765 PyObject *resultobj = 0;
33766 wxWindow *arg1 = (wxWindow *) 0 ;
33767 wxPoint *arg2 = 0 ;
33768 wxPoint result;
33769 void *argp1 = 0 ;
33770 int res1 = 0 ;
33771 wxPoint temp2 ;
33772 PyObject * obj0 = 0 ;
33773 PyObject * obj1 = 0 ;
33774 char * kwnames[] = {
33775 (char *) "self",(char *) "pt", NULL
33776 };
33777
33778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33780 if (!SWIG_IsOK(res1)) {
33781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33782 }
33783 arg1 = reinterpret_cast< wxWindow * >(argp1);
33784 {
33785 arg2 = &temp2;
33786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33787 }
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33795 return resultobj;
33796 fail:
33797 return NULL;
33798 }
33799
33800
33801 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33802 PyObject *resultobj = 0;
33803 wxWindow *arg1 = (wxWindow *) 0 ;
33804 wxSize *arg2 = 0 ;
33805 wxSize result;
33806 void *argp1 = 0 ;
33807 int res1 = 0 ;
33808 wxSize temp2 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 char * kwnames[] = {
33812 (char *) "self",(char *) "sz", NULL
33813 };
33814
33815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33817 if (!SWIG_IsOK(res1)) {
33818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33819 }
33820 arg1 = reinterpret_cast< wxWindow * >(argp1);
33821 {
33822 arg2 = &temp2;
33823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33824 }
33825 {
33826 PyThreadState* __tstate = wxPyBeginAllowThreads();
33827 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33828 wxPyEndAllowThreads(__tstate);
33829 if (PyErr_Occurred()) SWIG_fail;
33830 }
33831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33832 return resultobj;
33833 fail:
33834 return NULL;
33835 }
33836
33837
33838 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33839 PyObject *resultobj = 0;
33840 wxWindow *arg1 = (wxWindow *) 0 ;
33841 wxPoint *arg2 = 0 ;
33842 wxPoint result;
33843 void *argp1 = 0 ;
33844 int res1 = 0 ;
33845 wxPoint temp2 ;
33846 PyObject * obj0 = 0 ;
33847 PyObject * obj1 = 0 ;
33848 char * kwnames[] = {
33849 (char *) "self",(char *) "pt", NULL
33850 };
33851
33852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33856 }
33857 arg1 = reinterpret_cast< wxWindow * >(argp1);
33858 {
33859 arg2 = &temp2;
33860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33861 }
33862 {
33863 PyThreadState* __tstate = wxPyBeginAllowThreads();
33864 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33865 wxPyEndAllowThreads(__tstate);
33866 if (PyErr_Occurred()) SWIG_fail;
33867 }
33868 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33869 return resultobj;
33870 fail:
33871 return NULL;
33872 }
33873
33874
33875 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33876 PyObject *resultobj = 0;
33877 wxWindow *arg1 = (wxWindow *) 0 ;
33878 wxSize *arg2 = 0 ;
33879 wxSize result;
33880 void *argp1 = 0 ;
33881 int res1 = 0 ;
33882 wxSize temp2 ;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 char * kwnames[] = {
33886 (char *) "self",(char *) "sz", NULL
33887 };
33888
33889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33891 if (!SWIG_IsOK(res1)) {
33892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33893 }
33894 arg1 = reinterpret_cast< wxWindow * >(argp1);
33895 {
33896 arg2 = &temp2;
33897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33898 }
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33906 return resultobj;
33907 fail:
33908 return NULL;
33909 }
33910
33911
33912 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33913 PyObject *resultobj = 0;
33914 wxWindow *arg1 = (wxWindow *) 0 ;
33915 wxPoint *arg2 = 0 ;
33916 wxPoint result;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 wxPoint temp2 ;
33920 PyObject * obj0 = 0 ;
33921 PyObject * obj1 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "pt", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",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_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 {
33933 arg2 = &temp2;
33934 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33935 }
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj = 0;
33951 wxWindow *arg1 = (wxWindow *) 0 ;
33952 wxSize *arg2 = 0 ;
33953 wxSize result;
33954 void *argp1 = 0 ;
33955 int res1 = 0 ;
33956 wxSize temp2 ;
33957 PyObject * obj0 = 0 ;
33958 PyObject * obj1 = 0 ;
33959 char * kwnames[] = {
33960 (char *) "self",(char *) "sz", NULL
33961 };
33962
33963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33965 if (!SWIG_IsOK(res1)) {
33966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33967 }
33968 arg1 = reinterpret_cast< wxWindow * >(argp1);
33969 {
33970 arg2 = &temp2;
33971 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33972 }
33973 {
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33980 return resultobj;
33981 fail:
33982 return NULL;
33983 }
33984
33985
33986 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33987 PyObject *resultobj = 0;
33988 wxWindow *arg1 = (wxWindow *) 0 ;
33989 int arg2 ;
33990 int arg3 ;
33991 void *argp1 = 0 ;
33992 int res1 = 0 ;
33993 int val2 ;
33994 int ecode2 = 0 ;
33995 int val3 ;
33996 int ecode3 = 0 ;
33997 PyObject * obj0 = 0 ;
33998 PyObject * obj1 = 0 ;
33999 PyObject * obj2 = 0 ;
34000 char * kwnames[] = {
34001 (char *) "self",(char *) "x",(char *) "y", NULL
34002 };
34003
34004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34006 if (!SWIG_IsOK(res1)) {
34007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34008 }
34009 arg1 = reinterpret_cast< wxWindow * >(argp1);
34010 ecode2 = SWIG_AsVal_int(obj1, &val2);
34011 if (!SWIG_IsOK(ecode2)) {
34012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34013 }
34014 arg2 = static_cast< int >(val2);
34015 ecode3 = SWIG_AsVal_int(obj2, &val3);
34016 if (!SWIG_IsOK(ecode3)) {
34017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34018 }
34019 arg3 = static_cast< int >(val3);
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 (arg1)->WarpPointer(arg2,arg3);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_Py_Void();
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
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_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34045 }
34046 arg1 = reinterpret_cast< wxWindow * >(argp1);
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 (arg1)->CaptureMouse();
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 resultobj = SWIG_Py_Void();
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34061 PyObject *resultobj = 0;
34062 wxWindow *arg1 = (wxWindow *) 0 ;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 PyObject *swig_obj[1] ;
34066
34067 if (!args) SWIG_fail;
34068 swig_obj[0] = args;
34069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 {
34075 PyThreadState* __tstate = wxPyBeginAllowThreads();
34076 (arg1)->ReleaseMouse();
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 resultobj = SWIG_Py_Void();
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34088 PyObject *resultobj = 0;
34089 wxWindow *result = 0 ;
34090
34091 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34092 {
34093 if (!wxPyCheckForApp()) SWIG_fail;
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 result = (wxWindow *)wxWindow::GetCapture();
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 {
34100 resultobj = wxPyMake_wxObject(result, 0);
34101 }
34102 return resultobj;
34103 fail:
34104 return NULL;
34105 }
34106
34107
34108 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34109 PyObject *resultobj = 0;
34110 wxWindow *arg1 = (wxWindow *) 0 ;
34111 bool result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 PyObject *swig_obj[1] ;
34115
34116 if (!args) SWIG_fail;
34117 swig_obj[0] = args;
34118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34119 if (!SWIG_IsOK(res1)) {
34120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34121 }
34122 arg1 = reinterpret_cast< wxWindow * >(argp1);
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (bool)((wxWindow const *)arg1)->HasCapture();
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 {
34130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34131 }
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 bool arg2 = (bool) true ;
34142 wxRect *arg3 = (wxRect *) NULL ;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 bool val2 ;
34146 int ecode2 = 0 ;
34147 void *argp3 = 0 ;
34148 int res3 = 0 ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 PyObject * obj2 = 0 ;
34152 char * kwnames[] = {
34153 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34154 };
34155
34156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34158 if (!SWIG_IsOK(res1)) {
34159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34160 }
34161 arg1 = reinterpret_cast< wxWindow * >(argp1);
34162 if (obj1) {
34163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34164 if (!SWIG_IsOK(ecode2)) {
34165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34166 }
34167 arg2 = static_cast< bool >(val2);
34168 }
34169 if (obj2) {
34170 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34171 if (!SWIG_IsOK(res3)) {
34172 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34173 }
34174 arg3 = reinterpret_cast< wxRect * >(argp3);
34175 }
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxWindow *arg1 = (wxWindow *) 0 ;
34192 wxRect *arg2 = 0 ;
34193 bool arg3 = (bool) true ;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 wxRect temp2 ;
34197 bool val3 ;
34198 int ecode3 = 0 ;
34199 PyObject * obj0 = 0 ;
34200 PyObject * obj1 = 0 ;
34201 PyObject * obj2 = 0 ;
34202 char * kwnames[] = {
34203 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34204 };
34205
34206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 arg2 = &temp2;
34214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34215 }
34216 if (obj2) {
34217 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34218 if (!SWIG_IsOK(ecode3)) {
34219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34220 }
34221 arg3 = static_cast< bool >(val3);
34222 }
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 resultobj = SWIG_Py_Void();
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 void *argp1 = 0 ;
34240 int res1 = 0 ;
34241 PyObject *swig_obj[1] ;
34242
34243 if (!args) SWIG_fail;
34244 swig_obj[0] = args;
34245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34246 if (!SWIG_IsOK(res1)) {
34247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34248 }
34249 arg1 = reinterpret_cast< wxWindow * >(argp1);
34250 {
34251 PyThreadState* __tstate = wxPyBeginAllowThreads();
34252 (arg1)->Update();
34253 wxPyEndAllowThreads(__tstate);
34254 if (PyErr_Occurred()) SWIG_fail;
34255 }
34256 resultobj = SWIG_Py_Void();
34257 return resultobj;
34258 fail:
34259 return NULL;
34260 }
34261
34262
34263 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34264 PyObject *resultobj = 0;
34265 wxWindow *arg1 = (wxWindow *) 0 ;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 PyObject *swig_obj[1] ;
34269
34270 if (!args) SWIG_fail;
34271 swig_obj[0] = args;
34272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34273 if (!SWIG_IsOK(res1)) {
34274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34275 }
34276 arg1 = reinterpret_cast< wxWindow * >(argp1);
34277 {
34278 PyThreadState* __tstate = wxPyBeginAllowThreads();
34279 (arg1)->ClearBackground();
34280 wxPyEndAllowThreads(__tstate);
34281 if (PyErr_Occurred()) SWIG_fail;
34282 }
34283 resultobj = SWIG_Py_Void();
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34291 PyObject *resultobj = 0;
34292 wxWindow *arg1 = (wxWindow *) 0 ;
34293 void *argp1 = 0 ;
34294 int res1 = 0 ;
34295 PyObject *swig_obj[1] ;
34296
34297 if (!args) SWIG_fail;
34298 swig_obj[0] = args;
34299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34300 if (!SWIG_IsOK(res1)) {
34301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34302 }
34303 arg1 = reinterpret_cast< wxWindow * >(argp1);
34304 {
34305 PyThreadState* __tstate = wxPyBeginAllowThreads();
34306 (arg1)->Freeze();
34307 wxPyEndAllowThreads(__tstate);
34308 if (PyErr_Occurred()) SWIG_fail;
34309 }
34310 resultobj = SWIG_Py_Void();
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 void *argp1 = 0 ;
34321 int res1 = 0 ;
34322 PyObject *swig_obj[1] ;
34323
34324 if (!args) SWIG_fail;
34325 swig_obj[0] = args;
34326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 (arg1)->Thaw();
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 resultobj = SWIG_Py_Void();
34338 return resultobj;
34339 fail:
34340 return NULL;
34341 }
34342
34343
34344 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34345 PyObject *resultobj = 0;
34346 wxWindow *arg1 = (wxWindow *) 0 ;
34347 wxDC *arg2 = 0 ;
34348 void *argp1 = 0 ;
34349 int res1 = 0 ;
34350 void *argp2 = 0 ;
34351 int res2 = 0 ;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 char * kwnames[] = {
34355 (char *) "self",(char *) "dc", NULL
34356 };
34357
34358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34360 if (!SWIG_IsOK(res1)) {
34361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34362 }
34363 arg1 = reinterpret_cast< wxWindow * >(argp1);
34364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34365 if (!SWIG_IsOK(res2)) {
34366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34367 }
34368 if (!argp2) {
34369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34370 }
34371 arg2 = reinterpret_cast< wxDC * >(argp2);
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->PrepareDC(*arg2);
34375 wxPyEndAllowThreads(__tstate);
34376 if (PyErr_Occurred()) SWIG_fail;
34377 }
34378 resultobj = SWIG_Py_Void();
34379 return resultobj;
34380 fail:
34381 return NULL;
34382 }
34383
34384
34385 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34386 PyObject *resultobj = 0;
34387 wxWindow *arg1 = (wxWindow *) 0 ;
34388 wxRegion *result = 0 ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 {
34403 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34404 result = (wxRegion *) &_result_ref;
34405 }
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(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_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34429 }
34430 arg1 = reinterpret_cast< wxWindow * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
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_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj = 0;
34446 wxWindow *arg1 = (wxWindow *) 0 ;
34447 int arg2 ;
34448 int arg3 ;
34449 int arg4 = (int) 1 ;
34450 int arg5 = (int) 1 ;
34451 bool result;
34452 void *argp1 = 0 ;
34453 int res1 = 0 ;
34454 int val2 ;
34455 int ecode2 = 0 ;
34456 int val3 ;
34457 int ecode3 = 0 ;
34458 int val4 ;
34459 int ecode4 = 0 ;
34460 int val5 ;
34461 int ecode5 = 0 ;
34462 PyObject * obj0 = 0 ;
34463 PyObject * obj1 = 0 ;
34464 PyObject * obj2 = 0 ;
34465 PyObject * obj3 = 0 ;
34466 PyObject * obj4 = 0 ;
34467 char * kwnames[] = {
34468 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34469 };
34470
34471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34475 }
34476 arg1 = reinterpret_cast< wxWindow * >(argp1);
34477 ecode2 = SWIG_AsVal_int(obj1, &val2);
34478 if (!SWIG_IsOK(ecode2)) {
34479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34480 }
34481 arg2 = static_cast< int >(val2);
34482 ecode3 = SWIG_AsVal_int(obj2, &val3);
34483 if (!SWIG_IsOK(ecode3)) {
34484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34485 }
34486 arg3 = static_cast< int >(val3);
34487 if (obj3) {
34488 ecode4 = SWIG_AsVal_int(obj3, &val4);
34489 if (!SWIG_IsOK(ecode4)) {
34490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34491 }
34492 arg4 = static_cast< int >(val4);
34493 }
34494 if (obj4) {
34495 ecode5 = SWIG_AsVal_int(obj4, &val5);
34496 if (!SWIG_IsOK(ecode5)) {
34497 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34498 }
34499 arg5 = static_cast< int >(val5);
34500 }
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 {
34508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34509 }
34510 return resultobj;
34511 fail:
34512 return NULL;
34513 }
34514
34515
34516 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34517 PyObject *resultobj = 0;
34518 wxWindow *arg1 = (wxWindow *) 0 ;
34519 wxPoint *arg2 = 0 ;
34520 bool result;
34521 void *argp1 = 0 ;
34522 int res1 = 0 ;
34523 wxPoint temp2 ;
34524 PyObject * obj0 = 0 ;
34525 PyObject * obj1 = 0 ;
34526 char * kwnames[] = {
34527 (char *) "self",(char *) "pt", NULL
34528 };
34529
34530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34532 if (!SWIG_IsOK(res1)) {
34533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34534 }
34535 arg1 = reinterpret_cast< wxWindow * >(argp1);
34536 {
34537 arg2 = &temp2;
34538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34539 }
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 {
34547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34548 }
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34556 PyObject *resultobj = 0;
34557 wxWindow *arg1 = (wxWindow *) 0 ;
34558 wxRect *arg2 = 0 ;
34559 bool result;
34560 void *argp1 = 0 ;
34561 int res1 = 0 ;
34562 wxRect temp2 ;
34563 PyObject * obj0 = 0 ;
34564 PyObject * obj1 = 0 ;
34565 char * kwnames[] = {
34566 (char *) "self",(char *) "rect", NULL
34567 };
34568
34569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34571 if (!SWIG_IsOK(res1)) {
34572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34573 }
34574 arg1 = reinterpret_cast< wxWindow * >(argp1);
34575 {
34576 arg2 = &temp2;
34577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34578 }
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 {
34586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34587 }
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 SwigValueWrapper<wxVisualAttributes > result;
34598 void *argp1 = 0 ;
34599 int res1 = 0 ;
34600 PyObject *swig_obj[1] ;
34601
34602 if (!args) SWIG_fail;
34603 swig_obj[0] = args;
34604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 PyThreadState* __tstate = wxPyBeginAllowThreads();
34611 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34612 wxPyEndAllowThreads(__tstate);
34613 if (PyErr_Occurred()) SWIG_fail;
34614 }
34615 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34623 PyObject *resultobj = 0;
34624 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34625 SwigValueWrapper<wxVisualAttributes > result;
34626 int val1 ;
34627 int ecode1 = 0 ;
34628 PyObject * obj0 = 0 ;
34629 char * kwnames[] = {
34630 (char *) "variant", NULL
34631 };
34632
34633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34634 if (obj0) {
34635 ecode1 = SWIG_AsVal_int(obj0, &val1);
34636 if (!SWIG_IsOK(ecode1)) {
34637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34638 }
34639 arg1 = static_cast< wxWindowVariant >(val1);
34640 }
34641 {
34642 if (!wxPyCheckForApp()) SWIG_fail;
34643 PyThreadState* __tstate = wxPyBeginAllowThreads();
34644 result = wxWindow::GetClassDefaultAttributes(arg1);
34645 wxPyEndAllowThreads(__tstate);
34646 if (PyErr_Occurred()) SWIG_fail;
34647 }
34648 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34656 PyObject *resultobj = 0;
34657 wxWindow *arg1 = (wxWindow *) 0 ;
34658 wxColour *arg2 = 0 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 wxColour temp2 ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 char * kwnames[] = {
34666 (char *) "self",(char *) "colour", NULL
34667 };
34668
34669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34671 if (!SWIG_IsOK(res1)) {
34672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34673 }
34674 arg1 = reinterpret_cast< wxWindow * >(argp1);
34675 {
34676 arg2 = &temp2;
34677 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxWindow *arg1 = (wxWindow *) 0 ;
34697 wxColour *arg2 = 0 ;
34698 void *argp1 = 0 ;
34699 int res1 = 0 ;
34700 wxColour temp2 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char * kwnames[] = {
34704 (char *) "self",(char *) "colour", NULL
34705 };
34706
34707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34709 if (!SWIG_IsOK(res1)) {
34710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34711 }
34712 arg1 = reinterpret_cast< wxWindow * >(argp1);
34713 {
34714 arg2 = &temp2;
34715 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34716 }
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 resultobj = SWIG_Py_Void();
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 wxColour *arg2 = 0 ;
34734 bool result;
34735 void *argp1 = 0 ;
34736 int res1 = 0 ;
34737 wxColour temp2 ;
34738 PyObject * obj0 = 0 ;
34739 PyObject * obj1 = 0 ;
34740 char * kwnames[] = {
34741 (char *) "self",(char *) "colour", NULL
34742 };
34743
34744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34746 if (!SWIG_IsOK(res1)) {
34747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34748 }
34749 arg1 = reinterpret_cast< wxWindow * >(argp1);
34750 {
34751 arg2 = &temp2;
34752 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34753 }
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 {
34761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34762 }
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34770 PyObject *resultobj = 0;
34771 wxWindow *arg1 = (wxWindow *) 0 ;
34772 wxColour *arg2 = 0 ;
34773 void *argp1 = 0 ;
34774 int res1 = 0 ;
34775 wxColour temp2 ;
34776 PyObject * obj0 = 0 ;
34777 PyObject * obj1 = 0 ;
34778 char * kwnames[] = {
34779 (char *) "self",(char *) "colour", NULL
34780 };
34781
34782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 {
34789 arg2 = &temp2;
34790 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34791 }
34792 {
34793 PyThreadState* __tstate = wxPyBeginAllowThreads();
34794 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34795 wxPyEndAllowThreads(__tstate);
34796 if (PyErr_Occurred()) SWIG_fail;
34797 }
34798 resultobj = SWIG_Py_Void();
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34806 PyObject *resultobj = 0;
34807 wxWindow *arg1 = (wxWindow *) 0 ;
34808 wxColour result;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 PyObject *swig_obj[1] ;
34812
34813 if (!args) SWIG_fail;
34814 swig_obj[0] = args;
34815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34816 if (!SWIG_IsOK(res1)) {
34817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34818 }
34819 arg1 = reinterpret_cast< wxWindow * >(argp1);
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 wxColour result;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 PyObject *swig_obj[1] ;
34840
34841 if (!args) SWIG_fail;
34842 swig_obj[0] = args;
34843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 result = ((wxWindow const *)arg1)->GetForegroundColour();
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34862 PyObject *resultobj = 0;
34863 wxWindow *arg1 = (wxWindow *) 0 ;
34864 bool result;
34865 void *argp1 = 0 ;
34866 int res1 = 0 ;
34867 PyObject *swig_obj[1] ;
34868
34869 if (!args) SWIG_fail;
34870 swig_obj[0] = args;
34871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34892 PyObject *resultobj = 0;
34893 wxWindow *arg1 = (wxWindow *) 0 ;
34894 bool result;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 PyObject *swig_obj[1] ;
34898
34899 if (!args) SWIG_fail;
34900 swig_obj[0] = args;
34901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34902 if (!SWIG_IsOK(res1)) {
34903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34904 }
34905 arg1 = reinterpret_cast< wxWindow * >(argp1);
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 {
34913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34914 }
34915 return resultobj;
34916 fail:
34917 return NULL;
34918 }
34919
34920
34921 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34922 PyObject *resultobj = 0;
34923 wxWindow *arg1 = (wxWindow *) 0 ;
34924 wxBackgroundStyle arg2 ;
34925 bool result;
34926 void *argp1 = 0 ;
34927 int res1 = 0 ;
34928 int val2 ;
34929 int ecode2 = 0 ;
34930 PyObject * obj0 = 0 ;
34931 PyObject * obj1 = 0 ;
34932 char * kwnames[] = {
34933 (char *) "self",(char *) "style", NULL
34934 };
34935
34936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34938 if (!SWIG_IsOK(res1)) {
34939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34940 }
34941 arg1 = reinterpret_cast< wxWindow * >(argp1);
34942 ecode2 = SWIG_AsVal_int(obj1, &val2);
34943 if (!SWIG_IsOK(ecode2)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34945 }
34946 arg2 = static_cast< wxBackgroundStyle >(val2);
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 {
34954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34963 PyObject *resultobj = 0;
34964 wxWindow *arg1 = (wxWindow *) 0 ;
34965 wxBackgroundStyle result;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 PyObject *swig_obj[1] ;
34969
34970 if (!args) SWIG_fail;
34971 swig_obj[0] = args;
34972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34975 }
34976 arg1 = reinterpret_cast< wxWindow * >(argp1);
34977 {
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34980 wxPyEndAllowThreads(__tstate);
34981 if (PyErr_Occurred()) SWIG_fail;
34982 }
34983 resultobj = SWIG_From_int(static_cast< int >(result));
34984 return resultobj;
34985 fail:
34986 return NULL;
34987 }
34988
34989
34990 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34991 PyObject *resultobj = 0;
34992 wxWindow *arg1 = (wxWindow *) 0 ;
34993 bool result;
34994 void *argp1 = 0 ;
34995 int res1 = 0 ;
34996 PyObject *swig_obj[1] ;
34997
34998 if (!args) SWIG_fail;
34999 swig_obj[0] = args;
35000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35001 if (!SWIG_IsOK(res1)) {
35002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35003 }
35004 arg1 = reinterpret_cast< wxWindow * >(argp1);
35005 {
35006 PyThreadState* __tstate = wxPyBeginAllowThreads();
35007 result = (bool)(arg1)->HasTransparentBackground();
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 {
35012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35013 }
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj = 0;
35022 wxWindow *arg1 = (wxWindow *) 0 ;
35023 wxCursor *arg2 = 0 ;
35024 bool result;
35025 void *argp1 = 0 ;
35026 int res1 = 0 ;
35027 void *argp2 = 0 ;
35028 int res2 = 0 ;
35029 PyObject * obj0 = 0 ;
35030 PyObject * obj1 = 0 ;
35031 char * kwnames[] = {
35032 (char *) "self",(char *) "cursor", NULL
35033 };
35034
35035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35037 if (!SWIG_IsOK(res1)) {
35038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35039 }
35040 arg1 = reinterpret_cast< wxWindow * >(argp1);
35041 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35042 if (!SWIG_IsOK(res2)) {
35043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35044 }
35045 if (!argp2) {
35046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35047 }
35048 arg2 = reinterpret_cast< wxCursor * >(argp2);
35049 {
35050 PyThreadState* __tstate = wxPyBeginAllowThreads();
35051 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 {
35056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35057 }
35058 return resultobj;
35059 fail:
35060 return NULL;
35061 }
35062
35063
35064 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35065 PyObject *resultobj = 0;
35066 wxWindow *arg1 = (wxWindow *) 0 ;
35067 wxCursor result;
35068 void *argp1 = 0 ;
35069 int res1 = 0 ;
35070 PyObject *swig_obj[1] ;
35071
35072 if (!args) SWIG_fail;
35073 swig_obj[0] = args;
35074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35075 if (!SWIG_IsOK(res1)) {
35076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35077 }
35078 arg1 = reinterpret_cast< wxWindow * >(argp1);
35079 {
35080 PyThreadState* __tstate = wxPyBeginAllowThreads();
35081 result = (arg1)->GetCursor();
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = 0;
35094 wxWindow *arg1 = (wxWindow *) 0 ;
35095 wxFont *arg2 = 0 ;
35096 bool result;
35097 void *argp1 = 0 ;
35098 int res1 = 0 ;
35099 void *argp2 = 0 ;
35100 int res2 = 0 ;
35101 PyObject * obj0 = 0 ;
35102 PyObject * obj1 = 0 ;
35103 char * kwnames[] = {
35104 (char *) "self",(char *) "font", NULL
35105 };
35106
35107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35109 if (!SWIG_IsOK(res1)) {
35110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35111 }
35112 arg1 = reinterpret_cast< wxWindow * >(argp1);
35113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35114 if (!SWIG_IsOK(res2)) {
35115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35116 }
35117 if (!argp2) {
35118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35119 }
35120 arg2 = reinterpret_cast< wxFont * >(argp2);
35121 {
35122 PyThreadState* __tstate = wxPyBeginAllowThreads();
35123 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35124 wxPyEndAllowThreads(__tstate);
35125 if (PyErr_Occurred()) SWIG_fail;
35126 }
35127 {
35128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35129 }
35130 return resultobj;
35131 fail:
35132 return NULL;
35133 }
35134
35135
35136 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35137 PyObject *resultobj = 0;
35138 wxWindow *arg1 = (wxWindow *) 0 ;
35139 wxFont *arg2 = 0 ;
35140 void *argp1 = 0 ;
35141 int res1 = 0 ;
35142 void *argp2 = 0 ;
35143 int res2 = 0 ;
35144 PyObject * obj0 = 0 ;
35145 PyObject * obj1 = 0 ;
35146 char * kwnames[] = {
35147 (char *) "self",(char *) "font", NULL
35148 };
35149
35150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35154 }
35155 arg1 = reinterpret_cast< wxWindow * >(argp1);
35156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35157 if (!SWIG_IsOK(res2)) {
35158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35159 }
35160 if (!argp2) {
35161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35162 }
35163 arg2 = reinterpret_cast< wxFont * >(argp2);
35164 {
35165 PyThreadState* __tstate = wxPyBeginAllowThreads();
35166 (arg1)->SetOwnFont((wxFont const &)*arg2);
35167 wxPyEndAllowThreads(__tstate);
35168 if (PyErr_Occurred()) SWIG_fail;
35169 }
35170 resultobj = SWIG_Py_Void();
35171 return resultobj;
35172 fail:
35173 return NULL;
35174 }
35175
35176
35177 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35178 PyObject *resultobj = 0;
35179 wxWindow *arg1 = (wxWindow *) 0 ;
35180 wxFont result;
35181 void *argp1 = 0 ;
35182 int res1 = 0 ;
35183 PyObject *swig_obj[1] ;
35184
35185 if (!args) SWIG_fail;
35186 swig_obj[0] = args;
35187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35190 }
35191 arg1 = reinterpret_cast< wxWindow * >(argp1);
35192 {
35193 PyThreadState* __tstate = wxPyBeginAllowThreads();
35194 result = (arg1)->GetFont();
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35199 return resultobj;
35200 fail:
35201 return NULL;
35202 }
35203
35204
35205 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35206 PyObject *resultobj = 0;
35207 wxWindow *arg1 = (wxWindow *) 0 ;
35208 wxCaret *arg2 = (wxCaret *) 0 ;
35209 void *argp1 = 0 ;
35210 int res1 = 0 ;
35211 int res2 = 0 ;
35212 PyObject * obj0 = 0 ;
35213 PyObject * obj1 = 0 ;
35214 char * kwnames[] = {
35215 (char *) "self",(char *) "caret", NULL
35216 };
35217
35218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35220 if (!SWIG_IsOK(res1)) {
35221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35222 }
35223 arg1 = reinterpret_cast< wxWindow * >(argp1);
35224 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35225 if (!SWIG_IsOK(res2)) {
35226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35227 }
35228 {
35229 PyThreadState* __tstate = wxPyBeginAllowThreads();
35230 (arg1)->SetCaret(arg2);
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 resultobj = SWIG_Py_Void();
35235 return resultobj;
35236 fail:
35237 return NULL;
35238 }
35239
35240
35241 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35242 PyObject *resultobj = 0;
35243 wxWindow *arg1 = (wxWindow *) 0 ;
35244 wxCaret *result = 0 ;
35245 void *argp1 = 0 ;
35246 int res1 = 0 ;
35247 PyObject *swig_obj[1] ;
35248
35249 if (!args) SWIG_fail;
35250 swig_obj[0] = args;
35251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35252 if (!SWIG_IsOK(res1)) {
35253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35254 }
35255 arg1 = reinterpret_cast< wxWindow * >(argp1);
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35259 wxPyEndAllowThreads(__tstate);
35260 if (PyErr_Occurred()) SWIG_fail;
35261 }
35262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35263 return resultobj;
35264 fail:
35265 return NULL;
35266 }
35267
35268
35269 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35270 PyObject *resultobj = 0;
35271 wxWindow *arg1 = (wxWindow *) 0 ;
35272 int result;
35273 void *argp1 = 0 ;
35274 int res1 = 0 ;
35275 PyObject *swig_obj[1] ;
35276
35277 if (!args) SWIG_fail;
35278 swig_obj[0] = args;
35279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35280 if (!SWIG_IsOK(res1)) {
35281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35282 }
35283 arg1 = reinterpret_cast< wxWindow * >(argp1);
35284 {
35285 PyThreadState* __tstate = wxPyBeginAllowThreads();
35286 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35287 wxPyEndAllowThreads(__tstate);
35288 if (PyErr_Occurred()) SWIG_fail;
35289 }
35290 resultobj = SWIG_From_int(static_cast< int >(result));
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35298 PyObject *resultobj = 0;
35299 wxWindow *arg1 = (wxWindow *) 0 ;
35300 int result;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 PyObject *swig_obj[1] ;
35304
35305 if (!args) SWIG_fail;
35306 swig_obj[0] = args;
35307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35308 if (!SWIG_IsOK(res1)) {
35309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35310 }
35311 arg1 = reinterpret_cast< wxWindow * >(argp1);
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 resultobj = SWIG_From_int(static_cast< int >(result));
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35326 PyObject *resultobj = 0;
35327 wxWindow *arg1 = (wxWindow *) 0 ;
35328 wxString *arg2 = 0 ;
35329 int *arg3 = (int *) 0 ;
35330 int *arg4 = (int *) 0 ;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 bool temp2 = false ;
35334 int temp3 ;
35335 int res3 = SWIG_TMPOBJ ;
35336 int temp4 ;
35337 int res4 = SWIG_TMPOBJ ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "string", NULL
35342 };
35343
35344 arg3 = &temp3;
35345 arg4 = &temp4;
35346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35348 if (!SWIG_IsOK(res1)) {
35349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35350 }
35351 arg1 = reinterpret_cast< wxWindow * >(argp1);
35352 {
35353 arg2 = wxString_in_helper(obj1);
35354 if (arg2 == NULL) SWIG_fail;
35355 temp2 = true;
35356 }
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_Py_Void();
35364 if (SWIG_IsTmpObj(res3)) {
35365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35366 } else {
35367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35369 }
35370 if (SWIG_IsTmpObj(res4)) {
35371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35372 } else {
35373 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35375 }
35376 {
35377 if (temp2)
35378 delete arg2;
35379 }
35380 return resultobj;
35381 fail:
35382 {
35383 if (temp2)
35384 delete arg2;
35385 }
35386 return NULL;
35387 }
35388
35389
35390 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35391 PyObject *resultobj = 0;
35392 wxWindow *arg1 = (wxWindow *) 0 ;
35393 wxString *arg2 = 0 ;
35394 int *arg3 = (int *) 0 ;
35395 int *arg4 = (int *) 0 ;
35396 int *arg5 = (int *) 0 ;
35397 int *arg6 = (int *) 0 ;
35398 wxFont *arg7 = (wxFont *) NULL ;
35399 void *argp1 = 0 ;
35400 int res1 = 0 ;
35401 bool temp2 = false ;
35402 int temp3 ;
35403 int res3 = SWIG_TMPOBJ ;
35404 int temp4 ;
35405 int res4 = SWIG_TMPOBJ ;
35406 int temp5 ;
35407 int res5 = SWIG_TMPOBJ ;
35408 int temp6 ;
35409 int res6 = SWIG_TMPOBJ ;
35410 void *argp7 = 0 ;
35411 int res7 = 0 ;
35412 PyObject * obj0 = 0 ;
35413 PyObject * obj1 = 0 ;
35414 PyObject * obj2 = 0 ;
35415 char * kwnames[] = {
35416 (char *) "self",(char *) "string",(char *) "font", NULL
35417 };
35418
35419 arg3 = &temp3;
35420 arg4 = &temp4;
35421 arg5 = &temp5;
35422 arg6 = &temp6;
35423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35425 if (!SWIG_IsOK(res1)) {
35426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35427 }
35428 arg1 = reinterpret_cast< wxWindow * >(argp1);
35429 {
35430 arg2 = wxString_in_helper(obj1);
35431 if (arg2 == NULL) SWIG_fail;
35432 temp2 = true;
35433 }
35434 if (obj2) {
35435 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35436 if (!SWIG_IsOK(res7)) {
35437 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35438 }
35439 arg7 = reinterpret_cast< wxFont * >(argp7);
35440 }
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 resultobj = SWIG_Py_Void();
35448 if (SWIG_IsTmpObj(res3)) {
35449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35450 } else {
35451 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35453 }
35454 if (SWIG_IsTmpObj(res4)) {
35455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35456 } else {
35457 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35459 }
35460 if (SWIG_IsTmpObj(res5)) {
35461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35462 } else {
35463 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35465 }
35466 if (SWIG_IsTmpObj(res6)) {
35467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35468 } else {
35469 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35471 }
35472 {
35473 if (temp2)
35474 delete arg2;
35475 }
35476 return resultobj;
35477 fail:
35478 {
35479 if (temp2)
35480 delete arg2;
35481 }
35482 return NULL;
35483 }
35484
35485
35486 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35487 PyObject *resultobj = 0;
35488 wxWindow *arg1 = (wxWindow *) 0 ;
35489 int *arg2 = (int *) 0 ;
35490 int *arg3 = (int *) 0 ;
35491 void *argp1 = 0 ;
35492 int res1 = 0 ;
35493 int temp2 ;
35494 int res2 = 0 ;
35495 int temp3 ;
35496 int res3 = 0 ;
35497 PyObject * obj0 = 0 ;
35498 PyObject * obj1 = 0 ;
35499 PyObject * obj2 = 0 ;
35500 char * kwnames[] = {
35501 (char *) "self",(char *) "x",(char *) "y", NULL
35502 };
35503
35504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35506 if (!SWIG_IsOK(res1)) {
35507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35508 }
35509 arg1 = reinterpret_cast< wxWindow * >(argp1);
35510 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35511 int val;
35512 int ecode = SWIG_AsVal_int(obj1, &val);
35513 if (!SWIG_IsOK(ecode)) {
35514 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35515 }
35516 temp2 = static_cast< int >(val);
35517 arg2 = &temp2;
35518 res2 = SWIG_AddTmpMask(ecode);
35519 }
35520 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35521 int val;
35522 int ecode = SWIG_AsVal_int(obj2, &val);
35523 if (!SWIG_IsOK(ecode)) {
35524 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35525 }
35526 temp3 = static_cast< int >(val);
35527 arg3 = &temp3;
35528 res3 = SWIG_AddTmpMask(ecode);
35529 }
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 resultobj = SWIG_Py_Void();
35537 if (SWIG_IsTmpObj(res2)) {
35538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35539 } else {
35540 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35542 }
35543 if (SWIG_IsTmpObj(res3)) {
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35545 } else {
35546 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35548 }
35549 return resultobj;
35550 fail:
35551 return NULL;
35552 }
35553
35554
35555 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35556 PyObject *resultobj = 0;
35557 wxWindow *arg1 = (wxWindow *) 0 ;
35558 int *arg2 = (int *) 0 ;
35559 int *arg3 = (int *) 0 ;
35560 void *argp1 = 0 ;
35561 int res1 = 0 ;
35562 int temp2 ;
35563 int res2 = 0 ;
35564 int temp3 ;
35565 int res3 = 0 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 PyObject * obj2 = 0 ;
35569 char * kwnames[] = {
35570 (char *) "self",(char *) "x",(char *) "y", NULL
35571 };
35572
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35577 }
35578 arg1 = reinterpret_cast< wxWindow * >(argp1);
35579 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35580 int val;
35581 int ecode = SWIG_AsVal_int(obj1, &val);
35582 if (!SWIG_IsOK(ecode)) {
35583 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35584 }
35585 temp2 = static_cast< int >(val);
35586 arg2 = &temp2;
35587 res2 = SWIG_AddTmpMask(ecode);
35588 }
35589 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35590 int val;
35591 int ecode = SWIG_AsVal_int(obj2, &val);
35592 if (!SWIG_IsOK(ecode)) {
35593 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35594 }
35595 temp3 = static_cast< int >(val);
35596 arg3 = &temp3;
35597 res3 = SWIG_AddTmpMask(ecode);
35598 }
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_Py_Void();
35606 if (SWIG_IsTmpObj(res2)) {
35607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35608 } else {
35609 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35611 }
35612 if (SWIG_IsTmpObj(res3)) {
35613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35614 } else {
35615 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35617 }
35618 return resultobj;
35619 fail:
35620 return NULL;
35621 }
35622
35623
35624 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35625 PyObject *resultobj = 0;
35626 wxWindow *arg1 = (wxWindow *) 0 ;
35627 wxPoint *arg2 = 0 ;
35628 wxPoint result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 wxPoint temp2 ;
35632 PyObject * obj0 = 0 ;
35633 PyObject * obj1 = 0 ;
35634 char * kwnames[] = {
35635 (char *) "self",(char *) "pt", NULL
35636 };
35637
35638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35640 if (!SWIG_IsOK(res1)) {
35641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35642 }
35643 arg1 = reinterpret_cast< wxWindow * >(argp1);
35644 {
35645 arg2 = &temp2;
35646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35647 }
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj = 0;
35663 wxWindow *arg1 = (wxWindow *) 0 ;
35664 wxPoint *arg2 = 0 ;
35665 wxPoint result;
35666 void *argp1 = 0 ;
35667 int res1 = 0 ;
35668 wxPoint temp2 ;
35669 PyObject * obj0 = 0 ;
35670 PyObject * obj1 = 0 ;
35671 char * kwnames[] = {
35672 (char *) "self",(char *) "pt", NULL
35673 };
35674
35675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35677 if (!SWIG_IsOK(res1)) {
35678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35679 }
35680 arg1 = reinterpret_cast< wxWindow * >(argp1);
35681 {
35682 arg2 = &temp2;
35683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35684 }
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35699 PyObject *resultobj = 0;
35700 wxWindow *arg1 = (wxWindow *) 0 ;
35701 int arg2 ;
35702 int arg3 ;
35703 wxHitTest result;
35704 void *argp1 = 0 ;
35705 int res1 = 0 ;
35706 int val2 ;
35707 int ecode2 = 0 ;
35708 int val3 ;
35709 int ecode3 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 PyObject * obj2 = 0 ;
35713 char * kwnames[] = {
35714 (char *) "self",(char *) "x",(char *) "y", NULL
35715 };
35716
35717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35719 if (!SWIG_IsOK(res1)) {
35720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35721 }
35722 arg1 = reinterpret_cast< wxWindow * >(argp1);
35723 ecode2 = SWIG_AsVal_int(obj1, &val2);
35724 if (!SWIG_IsOK(ecode2)) {
35725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35726 }
35727 arg2 = static_cast< int >(val2);
35728 ecode3 = SWIG_AsVal_int(obj2, &val3);
35729 if (!SWIG_IsOK(ecode3)) {
35730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35731 }
35732 arg3 = static_cast< int >(val3);
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35736 wxPyEndAllowThreads(__tstate);
35737 if (PyErr_Occurred()) SWIG_fail;
35738 }
35739 resultobj = SWIG_From_int(static_cast< int >(result));
35740 return resultobj;
35741 fail:
35742 return NULL;
35743 }
35744
35745
35746 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35747 PyObject *resultobj = 0;
35748 wxWindow *arg1 = (wxWindow *) 0 ;
35749 wxPoint *arg2 = 0 ;
35750 wxHitTest result;
35751 void *argp1 = 0 ;
35752 int res1 = 0 ;
35753 wxPoint temp2 ;
35754 PyObject * obj0 = 0 ;
35755 PyObject * obj1 = 0 ;
35756 char * kwnames[] = {
35757 (char *) "self",(char *) "pt", NULL
35758 };
35759
35760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35762 if (!SWIG_IsOK(res1)) {
35763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35764 }
35765 arg1 = reinterpret_cast< wxWindow * >(argp1);
35766 {
35767 arg2 = &temp2;
35768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35769 }
35770 {
35771 PyThreadState* __tstate = wxPyBeginAllowThreads();
35772 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35773 wxPyEndAllowThreads(__tstate);
35774 if (PyErr_Occurred()) SWIG_fail;
35775 }
35776 resultobj = SWIG_From_int(static_cast< int >(result));
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35784 PyObject *resultobj = 0;
35785 wxWindow *arg1 = (wxWindow *) 0 ;
35786 long arg2 ;
35787 wxBorder result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 long val2 ;
35791 int ecode2 = 0 ;
35792
35793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35797 }
35798 arg1 = reinterpret_cast< wxWindow * >(argp1);
35799 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35800 if (!SWIG_IsOK(ecode2)) {
35801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35802 }
35803 arg2 = static_cast< long >(val2);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 resultobj = SWIG_From_int(static_cast< int >(result));
35811 return resultobj;
35812 fail:
35813 return NULL;
35814 }
35815
35816
35817 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35818 PyObject *resultobj = 0;
35819 wxWindow *arg1 = (wxWindow *) 0 ;
35820 wxBorder result;
35821 void *argp1 = 0 ;
35822 int res1 = 0 ;
35823
35824 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35826 if (!SWIG_IsOK(res1)) {
35827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35828 }
35829 arg1 = reinterpret_cast< wxWindow * >(argp1);
35830 {
35831 PyThreadState* __tstate = wxPyBeginAllowThreads();
35832 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 resultobj = SWIG_From_int(static_cast< int >(result));
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35844 int argc;
35845 PyObject *argv[3];
35846
35847 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35848 --argc;
35849 if (argc == 1) {
35850 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35851 }
35852 if (argc == 2) {
35853 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35854 }
35855
35856 fail:
35857 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35858 return NULL;
35859 }
35860
35861
35862 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35863 PyObject *resultobj = 0;
35864 wxWindow *arg1 = (wxWindow *) 0 ;
35865 long arg2 = (long) wxUPDATE_UI_NONE ;
35866 void *argp1 = 0 ;
35867 int res1 = 0 ;
35868 long val2 ;
35869 int ecode2 = 0 ;
35870 PyObject * obj0 = 0 ;
35871 PyObject * obj1 = 0 ;
35872 char * kwnames[] = {
35873 (char *) "self",(char *) "flags", NULL
35874 };
35875
35876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35878 if (!SWIG_IsOK(res1)) {
35879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35880 }
35881 arg1 = reinterpret_cast< wxWindow * >(argp1);
35882 if (obj1) {
35883 ecode2 = SWIG_AsVal_long(obj1, &val2);
35884 if (!SWIG_IsOK(ecode2)) {
35885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35886 }
35887 arg2 = static_cast< long >(val2);
35888 }
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 (arg1)->UpdateWindowUI(arg2);
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 resultobj = SWIG_Py_Void();
35896 return resultobj;
35897 fail:
35898 return NULL;
35899 }
35900
35901
35902 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35903 PyObject *resultobj = 0;
35904 wxWindow *arg1 = (wxWindow *) 0 ;
35905 wxMenu *arg2 = (wxMenu *) 0 ;
35906 int arg3 = (int) -1 ;
35907 int arg4 = (int) -1 ;
35908 bool result;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 void *argp2 = 0 ;
35912 int res2 = 0 ;
35913 int val3 ;
35914 int ecode3 = 0 ;
35915 int val4 ;
35916 int ecode4 = 0 ;
35917 PyObject * obj0 = 0 ;
35918 PyObject * obj1 = 0 ;
35919 PyObject * obj2 = 0 ;
35920 PyObject * obj3 = 0 ;
35921 char * kwnames[] = {
35922 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35923 };
35924
35925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35929 }
35930 arg1 = reinterpret_cast< wxWindow * >(argp1);
35931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35932 if (!SWIG_IsOK(res2)) {
35933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35934 }
35935 arg2 = reinterpret_cast< wxMenu * >(argp2);
35936 if (obj2) {
35937 ecode3 = SWIG_AsVal_int(obj2, &val3);
35938 if (!SWIG_IsOK(ecode3)) {
35939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35940 }
35941 arg3 = static_cast< int >(val3);
35942 }
35943 if (obj3) {
35944 ecode4 = SWIG_AsVal_int(obj3, &val4);
35945 if (!SWIG_IsOK(ecode4)) {
35946 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35947 }
35948 arg4 = static_cast< int >(val4);
35949 }
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 {
35957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35958 }
35959 return resultobj;
35960 fail:
35961 return NULL;
35962 }
35963
35964
35965 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35966 PyObject *resultobj = 0;
35967 wxWindow *arg1 = (wxWindow *) 0 ;
35968 wxMenu *arg2 = (wxMenu *) 0 ;
35969 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35970 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35971 bool result;
35972 void *argp1 = 0 ;
35973 int res1 = 0 ;
35974 void *argp2 = 0 ;
35975 int res2 = 0 ;
35976 wxPoint temp3 ;
35977 PyObject * obj0 = 0 ;
35978 PyObject * obj1 = 0 ;
35979 PyObject * obj2 = 0 ;
35980 char * kwnames[] = {
35981 (char *) "self",(char *) "menu",(char *) "pos", NULL
35982 };
35983
35984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35986 if (!SWIG_IsOK(res1)) {
35987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35988 }
35989 arg1 = reinterpret_cast< wxWindow * >(argp1);
35990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35991 if (!SWIG_IsOK(res2)) {
35992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35993 }
35994 arg2 = reinterpret_cast< wxMenu * >(argp2);
35995 if (obj2) {
35996 {
35997 arg3 = &temp3;
35998 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35999 }
36000 }
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 {
36008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36009 }
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 long result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 PyObject *swig_obj[1] ;
36023
36024 if (!args) SWIG_fail;
36025 swig_obj[0] = args;
36026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (long)wxWindow_GetHandle(arg1);
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 resultobj = SWIG_From_long(static_cast< long >(result));
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 long arg2 ;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 long val2 ;
36051 int ecode2 = 0 ;
36052 PyObject * obj0 = 0 ;
36053 PyObject * obj1 = 0 ;
36054 char * kwnames[] = {
36055 (char *) "self",(char *) "handle", NULL
36056 };
36057
36058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36060 if (!SWIG_IsOK(res1)) {
36061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36062 }
36063 arg1 = reinterpret_cast< wxWindow * >(argp1);
36064 ecode2 = SWIG_AsVal_long(obj1, &val2);
36065 if (!SWIG_IsOK(ecode2)) {
36066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36067 }
36068 arg2 = static_cast< long >(val2);
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 wxWindow_AssociateHandle(arg1,arg2);
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 resultobj = SWIG_Py_Void();
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 void *argp1 = 0 ;
36086 int res1 = 0 ;
36087 PyObject *swig_obj[1] ;
36088
36089 if (!args) SWIG_fail;
36090 swig_obj[0] = args;
36091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36092 if (!SWIG_IsOK(res1)) {
36093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36094 }
36095 arg1 = reinterpret_cast< wxWindow * >(argp1);
36096 {
36097 PyThreadState* __tstate = wxPyBeginAllowThreads();
36098 (arg1)->DissociateHandle();
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 resultobj = SWIG_Py_Void();
36103 return resultobj;
36104 fail:
36105 return NULL;
36106 }
36107
36108
36109 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36110 PyObject *resultobj = 0;
36111 wxWindow *arg1 = (wxWindow *) 0 ;
36112 wxPaintEvent *arg2 = 0 ;
36113 void *argp1 = 0 ;
36114 int res1 = 0 ;
36115 void *argp2 = 0 ;
36116 int res2 = 0 ;
36117 PyObject * obj0 = 0 ;
36118 PyObject * obj1 = 0 ;
36119 char * kwnames[] = {
36120 (char *) "self",(char *) "event", NULL
36121 };
36122
36123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36125 if (!SWIG_IsOK(res1)) {
36126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36127 }
36128 arg1 = reinterpret_cast< wxWindow * >(argp1);
36129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36130 if (!SWIG_IsOK(res2)) {
36131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36132 }
36133 if (!argp2) {
36134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36135 }
36136 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 (arg1)->OnPaint(*arg2);
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 resultobj = SWIG_Py_Void();
36144 return resultobj;
36145 fail:
36146 return NULL;
36147 }
36148
36149
36150 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36151 PyObject *resultobj = 0;
36152 wxWindow *arg1 = (wxWindow *) 0 ;
36153 int arg2 ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 int val2 ;
36158 int ecode2 = 0 ;
36159 PyObject * obj0 = 0 ;
36160 PyObject * obj1 = 0 ;
36161 char * kwnames[] = {
36162 (char *) "self",(char *) "orient", NULL
36163 };
36164
36165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36167 if (!SWIG_IsOK(res1)) {
36168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36169 }
36170 arg1 = reinterpret_cast< wxWindow * >(argp1);
36171 ecode2 = SWIG_AsVal_int(obj1, &val2);
36172 if (!SWIG_IsOK(ecode2)) {
36173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36174 }
36175 arg2 = static_cast< int >(val2);
36176 {
36177 PyThreadState* __tstate = wxPyBeginAllowThreads();
36178 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36179 wxPyEndAllowThreads(__tstate);
36180 if (PyErr_Occurred()) SWIG_fail;
36181 }
36182 {
36183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36184 }
36185 return resultobj;
36186 fail:
36187 return NULL;
36188 }
36189
36190
36191 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36192 PyObject *resultobj = 0;
36193 wxWindow *arg1 = (wxWindow *) 0 ;
36194 int arg2 ;
36195 int arg3 ;
36196 int arg4 ;
36197 int arg5 ;
36198 bool arg6 = (bool) true ;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 int val2 ;
36202 int ecode2 = 0 ;
36203 int val3 ;
36204 int ecode3 = 0 ;
36205 int val4 ;
36206 int ecode4 = 0 ;
36207 int val5 ;
36208 int ecode5 = 0 ;
36209 bool val6 ;
36210 int ecode6 = 0 ;
36211 PyObject * obj0 = 0 ;
36212 PyObject * obj1 = 0 ;
36213 PyObject * obj2 = 0 ;
36214 PyObject * obj3 = 0 ;
36215 PyObject * obj4 = 0 ;
36216 PyObject * obj5 = 0 ;
36217 char * kwnames[] = {
36218 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36219 };
36220
36221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36223 if (!SWIG_IsOK(res1)) {
36224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36225 }
36226 arg1 = reinterpret_cast< wxWindow * >(argp1);
36227 ecode2 = SWIG_AsVal_int(obj1, &val2);
36228 if (!SWIG_IsOK(ecode2)) {
36229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36230 }
36231 arg2 = static_cast< int >(val2);
36232 ecode3 = SWIG_AsVal_int(obj2, &val3);
36233 if (!SWIG_IsOK(ecode3)) {
36234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36235 }
36236 arg3 = static_cast< int >(val3);
36237 ecode4 = SWIG_AsVal_int(obj3, &val4);
36238 if (!SWIG_IsOK(ecode4)) {
36239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36240 }
36241 arg4 = static_cast< int >(val4);
36242 ecode5 = SWIG_AsVal_int(obj4, &val5);
36243 if (!SWIG_IsOK(ecode5)) {
36244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36245 }
36246 arg5 = static_cast< int >(val5);
36247 if (obj5) {
36248 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36249 if (!SWIG_IsOK(ecode6)) {
36250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36251 }
36252 arg6 = static_cast< bool >(val6);
36253 }
36254 {
36255 PyThreadState* __tstate = wxPyBeginAllowThreads();
36256 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36257 wxPyEndAllowThreads(__tstate);
36258 if (PyErr_Occurred()) SWIG_fail;
36259 }
36260 resultobj = SWIG_Py_Void();
36261 return resultobj;
36262 fail:
36263 return NULL;
36264 }
36265
36266
36267 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36268 PyObject *resultobj = 0;
36269 wxWindow *arg1 = (wxWindow *) 0 ;
36270 int arg2 ;
36271 int arg3 ;
36272 bool arg4 = (bool) true ;
36273 void *argp1 = 0 ;
36274 int res1 = 0 ;
36275 int val2 ;
36276 int ecode2 = 0 ;
36277 int val3 ;
36278 int ecode3 = 0 ;
36279 bool val4 ;
36280 int ecode4 = 0 ;
36281 PyObject * obj0 = 0 ;
36282 PyObject * obj1 = 0 ;
36283 PyObject * obj2 = 0 ;
36284 PyObject * obj3 = 0 ;
36285 char * kwnames[] = {
36286 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36287 };
36288
36289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36291 if (!SWIG_IsOK(res1)) {
36292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36293 }
36294 arg1 = reinterpret_cast< wxWindow * >(argp1);
36295 ecode2 = SWIG_AsVal_int(obj1, &val2);
36296 if (!SWIG_IsOK(ecode2)) {
36297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36298 }
36299 arg2 = static_cast< int >(val2);
36300 ecode3 = SWIG_AsVal_int(obj2, &val3);
36301 if (!SWIG_IsOK(ecode3)) {
36302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36303 }
36304 arg3 = static_cast< int >(val3);
36305 if (obj3) {
36306 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36307 if (!SWIG_IsOK(ecode4)) {
36308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36309 }
36310 arg4 = static_cast< bool >(val4);
36311 }
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 (arg1)->SetScrollPos(arg2,arg3,arg4);
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 resultobj = SWIG_Py_Void();
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36326 PyObject *resultobj = 0;
36327 wxWindow *arg1 = (wxWindow *) 0 ;
36328 int arg2 ;
36329 int result;
36330 void *argp1 = 0 ;
36331 int res1 = 0 ;
36332 int val2 ;
36333 int ecode2 = 0 ;
36334 PyObject * obj0 = 0 ;
36335 PyObject * obj1 = 0 ;
36336 char * kwnames[] = {
36337 (char *) "self",(char *) "orientation", NULL
36338 };
36339
36340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36342 if (!SWIG_IsOK(res1)) {
36343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36344 }
36345 arg1 = reinterpret_cast< wxWindow * >(argp1);
36346 ecode2 = SWIG_AsVal_int(obj1, &val2);
36347 if (!SWIG_IsOK(ecode2)) {
36348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36349 }
36350 arg2 = static_cast< int >(val2);
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 resultobj = SWIG_From_int(static_cast< int >(result));
36358 return resultobj;
36359 fail:
36360 return NULL;
36361 }
36362
36363
36364 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36365 PyObject *resultobj = 0;
36366 wxWindow *arg1 = (wxWindow *) 0 ;
36367 int arg2 ;
36368 int result;
36369 void *argp1 = 0 ;
36370 int res1 = 0 ;
36371 int val2 ;
36372 int ecode2 = 0 ;
36373 PyObject * obj0 = 0 ;
36374 PyObject * obj1 = 0 ;
36375 char * kwnames[] = {
36376 (char *) "self",(char *) "orientation", NULL
36377 };
36378
36379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36381 if (!SWIG_IsOK(res1)) {
36382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36383 }
36384 arg1 = reinterpret_cast< wxWindow * >(argp1);
36385 ecode2 = SWIG_AsVal_int(obj1, &val2);
36386 if (!SWIG_IsOK(ecode2)) {
36387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36388 }
36389 arg2 = static_cast< int >(val2);
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36393 wxPyEndAllowThreads(__tstate);
36394 if (PyErr_Occurred()) SWIG_fail;
36395 }
36396 resultobj = SWIG_From_int(static_cast< int >(result));
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 int arg2 ;
36407 int result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 int val2 ;
36411 int ecode2 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "orientation", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 ecode2 = SWIG_AsVal_int(obj1, &val2);
36425 if (!SWIG_IsOK(ecode2)) {
36426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36427 }
36428 arg2 = static_cast< int >(val2);
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 resultobj = SWIG_From_int(static_cast< int >(result));
36436 return resultobj;
36437 fail:
36438 return NULL;
36439 }
36440
36441
36442 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36443 PyObject *resultobj = 0;
36444 wxWindow *arg1 = (wxWindow *) 0 ;
36445 int arg2 ;
36446 int arg3 ;
36447 wxRect *arg4 = (wxRect *) NULL ;
36448 void *argp1 = 0 ;
36449 int res1 = 0 ;
36450 int val2 ;
36451 int ecode2 = 0 ;
36452 int val3 ;
36453 int ecode3 = 0 ;
36454 void *argp4 = 0 ;
36455 int res4 = 0 ;
36456 PyObject * obj0 = 0 ;
36457 PyObject * obj1 = 0 ;
36458 PyObject * obj2 = 0 ;
36459 PyObject * obj3 = 0 ;
36460 char * kwnames[] = {
36461 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36462 };
36463
36464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36466 if (!SWIG_IsOK(res1)) {
36467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36468 }
36469 arg1 = reinterpret_cast< wxWindow * >(argp1);
36470 ecode2 = SWIG_AsVal_int(obj1, &val2);
36471 if (!SWIG_IsOK(ecode2)) {
36472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36473 }
36474 arg2 = static_cast< int >(val2);
36475 ecode3 = SWIG_AsVal_int(obj2, &val3);
36476 if (!SWIG_IsOK(ecode3)) {
36477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36478 }
36479 arg3 = static_cast< int >(val3);
36480 if (obj3) {
36481 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36482 if (!SWIG_IsOK(res4)) {
36483 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36484 }
36485 arg4 = reinterpret_cast< wxRect * >(argp4);
36486 }
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 resultobj = SWIG_Py_Void();
36494 return resultobj;
36495 fail:
36496 return NULL;
36497 }
36498
36499
36500 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36501 PyObject *resultobj = 0;
36502 wxWindow *arg1 = (wxWindow *) 0 ;
36503 int arg2 ;
36504 bool result;
36505 void *argp1 = 0 ;
36506 int res1 = 0 ;
36507 int val2 ;
36508 int ecode2 = 0 ;
36509 PyObject * obj0 = 0 ;
36510 PyObject * obj1 = 0 ;
36511 char * kwnames[] = {
36512 (char *) "self",(char *) "lines", NULL
36513 };
36514
36515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36517 if (!SWIG_IsOK(res1)) {
36518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36519 }
36520 arg1 = reinterpret_cast< wxWindow * >(argp1);
36521 ecode2 = SWIG_AsVal_int(obj1, &val2);
36522 if (!SWIG_IsOK(ecode2)) {
36523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36524 }
36525 arg2 = static_cast< int >(val2);
36526 {
36527 PyThreadState* __tstate = wxPyBeginAllowThreads();
36528 result = (bool)(arg1)->ScrollLines(arg2);
36529 wxPyEndAllowThreads(__tstate);
36530 if (PyErr_Occurred()) SWIG_fail;
36531 }
36532 {
36533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36534 }
36535 return resultobj;
36536 fail:
36537 return NULL;
36538 }
36539
36540
36541 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj = 0;
36543 wxWindow *arg1 = (wxWindow *) 0 ;
36544 int arg2 ;
36545 bool result;
36546 void *argp1 = 0 ;
36547 int res1 = 0 ;
36548 int val2 ;
36549 int ecode2 = 0 ;
36550 PyObject * obj0 = 0 ;
36551 PyObject * obj1 = 0 ;
36552 char * kwnames[] = {
36553 (char *) "self",(char *) "pages", NULL
36554 };
36555
36556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36560 }
36561 arg1 = reinterpret_cast< wxWindow * >(argp1);
36562 ecode2 = SWIG_AsVal_int(obj1, &val2);
36563 if (!SWIG_IsOK(ecode2)) {
36564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36565 }
36566 arg2 = static_cast< int >(val2);
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 result = (bool)(arg1)->ScrollPages(arg2);
36570 wxPyEndAllowThreads(__tstate);
36571 if (PyErr_Occurred()) SWIG_fail;
36572 }
36573 {
36574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36575 }
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 bool result;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 PyObject *swig_obj[1] ;
36589
36590 if (!args) SWIG_fail;
36591 swig_obj[0] = args;
36592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36595 }
36596 arg1 = reinterpret_cast< wxWindow * >(argp1);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (bool)(arg1)->LineUp();
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 {
36604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36605 }
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 bool result;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 PyObject *swig_obj[1] ;
36619
36620 if (!args) SWIG_fail;
36621 swig_obj[0] = args;
36622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36623 if (!SWIG_IsOK(res1)) {
36624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36625 }
36626 arg1 = reinterpret_cast< wxWindow * >(argp1);
36627 {
36628 PyThreadState* __tstate = wxPyBeginAllowThreads();
36629 result = (bool)(arg1)->LineDown();
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 {
36634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36635 }
36636 return resultobj;
36637 fail:
36638 return NULL;
36639 }
36640
36641
36642 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36643 PyObject *resultobj = 0;
36644 wxWindow *arg1 = (wxWindow *) 0 ;
36645 bool result;
36646 void *argp1 = 0 ;
36647 int res1 = 0 ;
36648 PyObject *swig_obj[1] ;
36649
36650 if (!args) SWIG_fail;
36651 swig_obj[0] = args;
36652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36653 if (!SWIG_IsOK(res1)) {
36654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36655 }
36656 arg1 = reinterpret_cast< wxWindow * >(argp1);
36657 {
36658 PyThreadState* __tstate = wxPyBeginAllowThreads();
36659 result = (bool)(arg1)->PageUp();
36660 wxPyEndAllowThreads(__tstate);
36661 if (PyErr_Occurred()) SWIG_fail;
36662 }
36663 {
36664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36665 }
36666 return resultobj;
36667 fail:
36668 return NULL;
36669 }
36670
36671
36672 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36673 PyObject *resultobj = 0;
36674 wxWindow *arg1 = (wxWindow *) 0 ;
36675 bool result;
36676 void *argp1 = 0 ;
36677 int res1 = 0 ;
36678 PyObject *swig_obj[1] ;
36679
36680 if (!args) SWIG_fail;
36681 swig_obj[0] = args;
36682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36683 if (!SWIG_IsOK(res1)) {
36684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36685 }
36686 arg1 = reinterpret_cast< wxWindow * >(argp1);
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 result = (bool)(arg1)->PageDown();
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 {
36694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36695 }
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36703 PyObject *resultobj = 0;
36704 wxWindow *arg1 = (wxWindow *) 0 ;
36705 wxString *arg2 = 0 ;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 bool temp2 = false ;
36709 PyObject * obj0 = 0 ;
36710 PyObject * obj1 = 0 ;
36711 char * kwnames[] = {
36712 (char *) "self",(char *) "text", NULL
36713 };
36714
36715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36717 if (!SWIG_IsOK(res1)) {
36718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36719 }
36720 arg1 = reinterpret_cast< wxWindow * >(argp1);
36721 {
36722 arg2 = wxString_in_helper(obj1);
36723 if (arg2 == NULL) SWIG_fail;
36724 temp2 = true;
36725 }
36726 {
36727 PyThreadState* __tstate = wxPyBeginAllowThreads();
36728 (arg1)->SetHelpText((wxString const &)*arg2);
36729 wxPyEndAllowThreads(__tstate);
36730 if (PyErr_Occurred()) SWIG_fail;
36731 }
36732 resultobj = SWIG_Py_Void();
36733 {
36734 if (temp2)
36735 delete arg2;
36736 }
36737 return resultobj;
36738 fail:
36739 {
36740 if (temp2)
36741 delete arg2;
36742 }
36743 return NULL;
36744 }
36745
36746
36747 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36748 PyObject *resultobj = 0;
36749 wxWindow *arg1 = (wxWindow *) 0 ;
36750 wxString *arg2 = 0 ;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 bool temp2 = false ;
36754 PyObject * obj0 = 0 ;
36755 PyObject * obj1 = 0 ;
36756 char * kwnames[] = {
36757 (char *) "self",(char *) "text", NULL
36758 };
36759
36760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 {
36767 arg2 = wxString_in_helper(obj1);
36768 if (arg2 == NULL) SWIG_fail;
36769 temp2 = true;
36770 }
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 resultobj = SWIG_Py_Void();
36778 {
36779 if (temp2)
36780 delete arg2;
36781 }
36782 return resultobj;
36783 fail:
36784 {
36785 if (temp2)
36786 delete arg2;
36787 }
36788 return NULL;
36789 }
36790
36791
36792 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36793 PyObject *resultobj = 0;
36794 wxWindow *arg1 = (wxWindow *) 0 ;
36795 wxString result;
36796 void *argp1 = 0 ;
36797 int res1 = 0 ;
36798 PyObject *swig_obj[1] ;
36799
36800 if (!args) SWIG_fail;
36801 swig_obj[0] = args;
36802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36803 if (!SWIG_IsOK(res1)) {
36804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36805 }
36806 arg1 = reinterpret_cast< wxWindow * >(argp1);
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 result = ((wxWindow const *)arg1)->GetHelpText();
36810 wxPyEndAllowThreads(__tstate);
36811 if (PyErr_Occurred()) SWIG_fail;
36812 }
36813 {
36814 #if wxUSE_UNICODE
36815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36816 #else
36817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36818 #endif
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 wxString *arg2 = 0 ;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 bool temp2 = false ;
36833 PyObject * obj0 = 0 ;
36834 PyObject * obj1 = 0 ;
36835 char * kwnames[] = {
36836 (char *) "self",(char *) "tip", NULL
36837 };
36838
36839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36841 if (!SWIG_IsOK(res1)) {
36842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36843 }
36844 arg1 = reinterpret_cast< wxWindow * >(argp1);
36845 {
36846 arg2 = wxString_in_helper(obj1);
36847 if (arg2 == NULL) SWIG_fail;
36848 temp2 = true;
36849 }
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 (arg1)->SetToolTip((wxString const &)*arg2);
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 resultobj = SWIG_Py_Void();
36857 {
36858 if (temp2)
36859 delete arg2;
36860 }
36861 return resultobj;
36862 fail:
36863 {
36864 if (temp2)
36865 delete arg2;
36866 }
36867 return NULL;
36868 }
36869
36870
36871 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36872 PyObject *resultobj = 0;
36873 wxWindow *arg1 = (wxWindow *) 0 ;
36874 wxToolTip *arg2 = (wxToolTip *) 0 ;
36875 void *argp1 = 0 ;
36876 int res1 = 0 ;
36877 int res2 = 0 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char * kwnames[] = {
36881 (char *) "self",(char *) "tip", NULL
36882 };
36883
36884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36886 if (!SWIG_IsOK(res1)) {
36887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36888 }
36889 arg1 = reinterpret_cast< wxWindow * >(argp1);
36890 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36891 if (!SWIG_IsOK(res2)) {
36892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36893 }
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 (arg1)->SetToolTip(arg2);
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 resultobj = SWIG_Py_Void();
36901 return resultobj;
36902 fail:
36903 return NULL;
36904 }
36905
36906
36907 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36908 PyObject *resultobj = 0;
36909 wxWindow *arg1 = (wxWindow *) 0 ;
36910 wxToolTip *result = 0 ;
36911 void *argp1 = 0 ;
36912 int res1 = 0 ;
36913 PyObject *swig_obj[1] ;
36914
36915 if (!args) SWIG_fail;
36916 swig_obj[0] = args;
36917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 {
36929 resultobj = wxPyMake_wxObject(result, (bool)0);
36930 }
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36938 PyObject *resultobj = 0;
36939 wxWindow *arg1 = (wxWindow *) 0 ;
36940 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36941 void *argp1 = 0 ;
36942 int res1 = 0 ;
36943 int res2 = 0 ;
36944 PyObject * obj0 = 0 ;
36945 PyObject * obj1 = 0 ;
36946 char * kwnames[] = {
36947 (char *) "self",(char *) "dropTarget", NULL
36948 };
36949
36950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36952 if (!SWIG_IsOK(res1)) {
36953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36954 }
36955 arg1 = reinterpret_cast< wxWindow * >(argp1);
36956 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36957 if (!SWIG_IsOK(res2)) {
36958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36959 }
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 (arg1)->SetDropTarget(arg2);
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_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 wxPyDropTarget *result = 0 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 PyObject *swig_obj[1] ;
36980
36981 if (!args) SWIG_fail;
36982 swig_obj[0] = args;
36983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36984 if (!SWIG_IsOK(res1)) {
36985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36986 }
36987 arg1 = reinterpret_cast< wxWindow * >(argp1);
36988 {
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36991 wxPyEndAllowThreads(__tstate);
36992 if (PyErr_Occurred()) SWIG_fail;
36993 }
36994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36995 return resultobj;
36996 fail:
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 bool arg2 ;
37005 void *argp1 = 0 ;
37006 int res1 = 0 ;
37007 bool val2 ;
37008 int ecode2 = 0 ;
37009 PyObject * obj0 = 0 ;
37010 PyObject * obj1 = 0 ;
37011 char * kwnames[] = {
37012 (char *) "self",(char *) "accept", NULL
37013 };
37014
37015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37017 if (!SWIG_IsOK(res1)) {
37018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37019 }
37020 arg1 = reinterpret_cast< wxWindow * >(argp1);
37021 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37022 if (!SWIG_IsOK(ecode2)) {
37023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37024 }
37025 arg2 = static_cast< bool >(val2);
37026 {
37027 PyThreadState* __tstate = wxPyBeginAllowThreads();
37028 (arg1)->DragAcceptFiles(arg2);
37029 wxPyEndAllowThreads(__tstate);
37030 if (PyErr_Occurred()) SWIG_fail;
37031 }
37032 resultobj = SWIG_Py_Void();
37033 return resultobj;
37034 fail:
37035 return NULL;
37036 }
37037
37038
37039 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37040 PyObject *resultobj = 0;
37041 wxWindow *arg1 = (wxWindow *) 0 ;
37042 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37043 void *argp1 = 0 ;
37044 int res1 = 0 ;
37045 int res2 = 0 ;
37046 PyObject * obj0 = 0 ;
37047 PyObject * obj1 = 0 ;
37048 char * kwnames[] = {
37049 (char *) "self",(char *) "constraints", NULL
37050 };
37051
37052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37056 }
37057 arg1 = reinterpret_cast< wxWindow * >(argp1);
37058 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37059 if (!SWIG_IsOK(res2)) {
37060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37061 }
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 (arg1)->SetConstraints(arg2);
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 resultobj = SWIG_Py_Void();
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37076 PyObject *resultobj = 0;
37077 wxWindow *arg1 = (wxWindow *) 0 ;
37078 wxLayoutConstraints *result = 0 ;
37079 void *argp1 = 0 ;
37080 int res1 = 0 ;
37081 PyObject *swig_obj[1] ;
37082
37083 if (!args) SWIG_fail;
37084 swig_obj[0] = args;
37085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 {
37091 PyThreadState* __tstate = wxPyBeginAllowThreads();
37092 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37093 wxPyEndAllowThreads(__tstate);
37094 if (PyErr_Occurred()) SWIG_fail;
37095 }
37096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37097 return resultobj;
37098 fail:
37099 return NULL;
37100 }
37101
37102
37103 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37104 PyObject *resultobj = 0;
37105 wxWindow *arg1 = (wxWindow *) 0 ;
37106 bool arg2 ;
37107 void *argp1 = 0 ;
37108 int res1 = 0 ;
37109 bool val2 ;
37110 int ecode2 = 0 ;
37111 PyObject * obj0 = 0 ;
37112 PyObject * obj1 = 0 ;
37113 char * kwnames[] = {
37114 (char *) "self",(char *) "autoLayout", NULL
37115 };
37116
37117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37119 if (!SWIG_IsOK(res1)) {
37120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37121 }
37122 arg1 = reinterpret_cast< wxWindow * >(argp1);
37123 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37124 if (!SWIG_IsOK(ecode2)) {
37125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37126 }
37127 arg2 = static_cast< bool >(val2);
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 (arg1)->SetAutoLayout(arg2);
37131 wxPyEndAllowThreads(__tstate);
37132 if (PyErr_Occurred()) SWIG_fail;
37133 }
37134 resultobj = SWIG_Py_Void();
37135 return resultobj;
37136 fail:
37137 return NULL;
37138 }
37139
37140
37141 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37142 PyObject *resultobj = 0;
37143 wxWindow *arg1 = (wxWindow *) 0 ;
37144 bool result;
37145 void *argp1 = 0 ;
37146 int res1 = 0 ;
37147 PyObject *swig_obj[1] ;
37148
37149 if (!args) SWIG_fail;
37150 swig_obj[0] = args;
37151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37152 if (!SWIG_IsOK(res1)) {
37153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37154 }
37155 arg1 = reinterpret_cast< wxWindow * >(argp1);
37156 {
37157 PyThreadState* __tstate = wxPyBeginAllowThreads();
37158 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37164 }
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 bool result;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 PyObject *swig_obj[1] ;
37178
37179 if (!args) SWIG_fail;
37180 swig_obj[0] = args;
37181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (bool)(arg1)->Layout();
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 {
37193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37194 }
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 wxSizer *arg2 = (wxSizer *) 0 ;
37205 bool arg3 = (bool) true ;
37206 void *argp1 = 0 ;
37207 int res1 = 0 ;
37208 int res2 = 0 ;
37209 bool val3 ;
37210 int ecode3 = 0 ;
37211 PyObject * obj0 = 0 ;
37212 PyObject * obj1 = 0 ;
37213 PyObject * obj2 = 0 ;
37214 char * kwnames[] = {
37215 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37216 };
37217
37218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37220 if (!SWIG_IsOK(res1)) {
37221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37222 }
37223 arg1 = reinterpret_cast< wxWindow * >(argp1);
37224 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37225 if (!SWIG_IsOK(res2)) {
37226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37227 }
37228 if (obj2) {
37229 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37230 if (!SWIG_IsOK(ecode3)) {
37231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37232 }
37233 arg3 = static_cast< bool >(val3);
37234 }
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 (arg1)->SetSizer(arg2,arg3);
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 resultobj = SWIG_Py_Void();
37242 return resultobj;
37243 fail:
37244 return NULL;
37245 }
37246
37247
37248 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37249 PyObject *resultobj = 0;
37250 wxWindow *arg1 = (wxWindow *) 0 ;
37251 wxSizer *arg2 = (wxSizer *) 0 ;
37252 bool arg3 = (bool) true ;
37253 void *argp1 = 0 ;
37254 int res1 = 0 ;
37255 int res2 = 0 ;
37256 bool val3 ;
37257 int ecode3 = 0 ;
37258 PyObject * obj0 = 0 ;
37259 PyObject * obj1 = 0 ;
37260 PyObject * obj2 = 0 ;
37261 char * kwnames[] = {
37262 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37263 };
37264
37265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37267 if (!SWIG_IsOK(res1)) {
37268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37269 }
37270 arg1 = reinterpret_cast< wxWindow * >(argp1);
37271 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37272 if (!SWIG_IsOK(res2)) {
37273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37274 }
37275 if (obj2) {
37276 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37277 if (!SWIG_IsOK(ecode3)) {
37278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37279 }
37280 arg3 = static_cast< bool >(val3);
37281 }
37282 {
37283 PyThreadState* __tstate = wxPyBeginAllowThreads();
37284 (arg1)->SetSizerAndFit(arg2,arg3);
37285 wxPyEndAllowThreads(__tstate);
37286 if (PyErr_Occurred()) SWIG_fail;
37287 }
37288 resultobj = SWIG_Py_Void();
37289 return resultobj;
37290 fail:
37291 return NULL;
37292 }
37293
37294
37295 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37296 PyObject *resultobj = 0;
37297 wxWindow *arg1 = (wxWindow *) 0 ;
37298 wxSizer *result = 0 ;
37299 void *argp1 = 0 ;
37300 int res1 = 0 ;
37301 PyObject *swig_obj[1] ;
37302
37303 if (!args) SWIG_fail;
37304 swig_obj[0] = args;
37305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37306 if (!SWIG_IsOK(res1)) {
37307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37308 }
37309 arg1 = reinterpret_cast< wxWindow * >(argp1);
37310 {
37311 PyThreadState* __tstate = wxPyBeginAllowThreads();
37312 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37313 wxPyEndAllowThreads(__tstate);
37314 if (PyErr_Occurred()) SWIG_fail;
37315 }
37316 {
37317 resultobj = wxPyMake_wxObject(result, (bool)0);
37318 }
37319 return resultobj;
37320 fail:
37321 return NULL;
37322 }
37323
37324
37325 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37326 PyObject *resultobj = 0;
37327 wxWindow *arg1 = (wxWindow *) 0 ;
37328 wxSizer *arg2 = (wxSizer *) 0 ;
37329 void *argp1 = 0 ;
37330 int res1 = 0 ;
37331 void *argp2 = 0 ;
37332 int res2 = 0 ;
37333 PyObject * obj0 = 0 ;
37334 PyObject * obj1 = 0 ;
37335 char * kwnames[] = {
37336 (char *) "self",(char *) "sizer", NULL
37337 };
37338
37339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37341 if (!SWIG_IsOK(res1)) {
37342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37343 }
37344 arg1 = reinterpret_cast< wxWindow * >(argp1);
37345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37346 if (!SWIG_IsOK(res2)) {
37347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37348 }
37349 arg2 = reinterpret_cast< wxSizer * >(argp2);
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 (arg1)->SetContainingSizer(arg2);
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 resultobj = SWIG_Py_Void();
37357 return resultobj;
37358 fail:
37359 return NULL;
37360 }
37361
37362
37363 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37364 PyObject *resultobj = 0;
37365 wxWindow *arg1 = (wxWindow *) 0 ;
37366 wxSizer *result = 0 ;
37367 void *argp1 = 0 ;
37368 int res1 = 0 ;
37369 PyObject *swig_obj[1] ;
37370
37371 if (!args) SWIG_fail;
37372 swig_obj[0] = args;
37373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37374 if (!SWIG_IsOK(res1)) {
37375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37376 }
37377 arg1 = reinterpret_cast< wxWindow * >(argp1);
37378 {
37379 PyThreadState* __tstate = wxPyBeginAllowThreads();
37380 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37381 wxPyEndAllowThreads(__tstate);
37382 if (PyErr_Occurred()) SWIG_fail;
37383 }
37384 {
37385 resultobj = wxPyMake_wxObject(result, (bool)0);
37386 }
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37394 PyObject *resultobj = 0;
37395 wxWindow *arg1 = (wxWindow *) 0 ;
37396 void *argp1 = 0 ;
37397 int res1 = 0 ;
37398 PyObject *swig_obj[1] ;
37399
37400 if (!args) SWIG_fail;
37401 swig_obj[0] = args;
37402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37403 if (!SWIG_IsOK(res1)) {
37404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37405 }
37406 arg1 = reinterpret_cast< wxWindow * >(argp1);
37407 {
37408 PyThreadState* __tstate = wxPyBeginAllowThreads();
37409 (arg1)->InheritAttributes();
37410 wxPyEndAllowThreads(__tstate);
37411 if (PyErr_Occurred()) SWIG_fail;
37412 }
37413 resultobj = SWIG_Py_Void();
37414 return resultobj;
37415 fail:
37416 return NULL;
37417 }
37418
37419
37420 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37421 PyObject *resultobj = 0;
37422 wxWindow *arg1 = (wxWindow *) 0 ;
37423 bool result;
37424 void *argp1 = 0 ;
37425 int res1 = 0 ;
37426 PyObject *swig_obj[1] ;
37427
37428 if (!args) SWIG_fail;
37429 swig_obj[0] = args;
37430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37431 if (!SWIG_IsOK(res1)) {
37432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37433 }
37434 arg1 = reinterpret_cast< wxWindow * >(argp1);
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37438 wxPyEndAllowThreads(__tstate);
37439 if (PyErr_Occurred()) SWIG_fail;
37440 }
37441 {
37442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37443 }
37444 return resultobj;
37445 fail:
37446 return NULL;
37447 }
37448
37449
37450 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37451 PyObject *obj;
37452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37453 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37454 return SWIG_Py_Void();
37455 }
37456
37457 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37458 return SWIG_Python_InitShadowInstance(args);
37459 }
37460
37461 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37462 PyObject *resultobj = 0;
37463 long arg1 ;
37464 wxWindow *arg2 = (wxWindow *) NULL ;
37465 wxWindow *result = 0 ;
37466 long val1 ;
37467 int ecode1 = 0 ;
37468 void *argp2 = 0 ;
37469 int res2 = 0 ;
37470 PyObject * obj0 = 0 ;
37471 PyObject * obj1 = 0 ;
37472 char * kwnames[] = {
37473 (char *) "id",(char *) "parent", NULL
37474 };
37475
37476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37477 ecode1 = SWIG_AsVal_long(obj0, &val1);
37478 if (!SWIG_IsOK(ecode1)) {
37479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37480 }
37481 arg1 = static_cast< long >(val1);
37482 if (obj1) {
37483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37484 if (!SWIG_IsOK(res2)) {
37485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37486 }
37487 arg2 = reinterpret_cast< wxWindow * >(argp2);
37488 }
37489 {
37490 if (!wxPyCheckForApp()) SWIG_fail;
37491 PyThreadState* __tstate = wxPyBeginAllowThreads();
37492 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37493 wxPyEndAllowThreads(__tstate);
37494 if (PyErr_Occurred()) SWIG_fail;
37495 }
37496 {
37497 resultobj = wxPyMake_wxObject(result, 0);
37498 }
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37506 PyObject *resultobj = 0;
37507 wxString *arg1 = 0 ;
37508 wxWindow *arg2 = (wxWindow *) NULL ;
37509 wxWindow *result = 0 ;
37510 bool temp1 = false ;
37511 void *argp2 = 0 ;
37512 int res2 = 0 ;
37513 PyObject * obj0 = 0 ;
37514 PyObject * obj1 = 0 ;
37515 char * kwnames[] = {
37516 (char *) "name",(char *) "parent", NULL
37517 };
37518
37519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37520 {
37521 arg1 = wxString_in_helper(obj0);
37522 if (arg1 == NULL) SWIG_fail;
37523 temp1 = true;
37524 }
37525 if (obj1) {
37526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37527 if (!SWIG_IsOK(res2)) {
37528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37529 }
37530 arg2 = reinterpret_cast< wxWindow * >(argp2);
37531 }
37532 {
37533 if (!wxPyCheckForApp()) SWIG_fail;
37534 PyThreadState* __tstate = wxPyBeginAllowThreads();
37535 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37536 wxPyEndAllowThreads(__tstate);
37537 if (PyErr_Occurred()) SWIG_fail;
37538 }
37539 {
37540 resultobj = wxPyMake_wxObject(result, 0);
37541 }
37542 {
37543 if (temp1)
37544 delete arg1;
37545 }
37546 return resultobj;
37547 fail:
37548 {
37549 if (temp1)
37550 delete arg1;
37551 }
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37557 PyObject *resultobj = 0;
37558 wxString *arg1 = 0 ;
37559 wxWindow *arg2 = (wxWindow *) NULL ;
37560 wxWindow *result = 0 ;
37561 bool temp1 = false ;
37562 void *argp2 = 0 ;
37563 int res2 = 0 ;
37564 PyObject * obj0 = 0 ;
37565 PyObject * obj1 = 0 ;
37566 char * kwnames[] = {
37567 (char *) "label",(char *) "parent", NULL
37568 };
37569
37570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37571 {
37572 arg1 = wxString_in_helper(obj0);
37573 if (arg1 == NULL) SWIG_fail;
37574 temp1 = true;
37575 }
37576 if (obj1) {
37577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37578 if (!SWIG_IsOK(res2)) {
37579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37580 }
37581 arg2 = reinterpret_cast< wxWindow * >(argp2);
37582 }
37583 {
37584 if (!wxPyCheckForApp()) SWIG_fail;
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37587 wxPyEndAllowThreads(__tstate);
37588 if (PyErr_Occurred()) SWIG_fail;
37589 }
37590 {
37591 resultobj = wxPyMake_wxObject(result, 0);
37592 }
37593 {
37594 if (temp1)
37595 delete arg1;
37596 }
37597 return resultobj;
37598 fail:
37599 {
37600 if (temp1)
37601 delete arg1;
37602 }
37603 return NULL;
37604 }
37605
37606
37607 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37608 PyObject *resultobj = 0;
37609 wxWindow *arg1 = (wxWindow *) 0 ;
37610 unsigned long arg2 ;
37611 wxWindow *result = 0 ;
37612 void *argp1 = 0 ;
37613 int res1 = 0 ;
37614 unsigned long val2 ;
37615 int ecode2 = 0 ;
37616 PyObject * obj0 = 0 ;
37617 PyObject * obj1 = 0 ;
37618 char * kwnames[] = {
37619 (char *) "parent",(char *) "_hWnd", NULL
37620 };
37621
37622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37624 if (!SWIG_IsOK(res1)) {
37625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37626 }
37627 arg1 = reinterpret_cast< wxWindow * >(argp1);
37628 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37629 if (!SWIG_IsOK(ecode2)) {
37630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37631 }
37632 arg2 = static_cast< unsigned long >(val2);
37633 {
37634 PyThreadState* __tstate = wxPyBeginAllowThreads();
37635 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37636 wxPyEndAllowThreads(__tstate);
37637 if (PyErr_Occurred()) SWIG_fail;
37638 }
37639 {
37640 resultobj = wxPyMake_wxObject(result, 0);
37641 }
37642 return resultobj;
37643 fail:
37644 return NULL;
37645 }
37646
37647
37648 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37649 PyObject *resultobj = 0;
37650 PyObject *result = 0 ;
37651
37652 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37653 {
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 result = (PyObject *)GetTopLevelWindows();
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 resultobj = result;
37660 return resultobj;
37661 fail:
37662 return NULL;
37663 }
37664
37665
37666 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37667 PyObject *resultobj = 0;
37668 wxValidator *result = 0 ;
37669
37670 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37671 {
37672 PyThreadState* __tstate = wxPyBeginAllowThreads();
37673 result = (wxValidator *)new wxValidator();
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37678 return resultobj;
37679 fail:
37680 return NULL;
37681 }
37682
37683
37684 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37685 PyObject *resultobj = 0;
37686 wxValidator *arg1 = (wxValidator *) 0 ;
37687 wxValidator *result = 0 ;
37688 void *argp1 = 0 ;
37689 int res1 = 0 ;
37690 PyObject *swig_obj[1] ;
37691
37692 if (!args) SWIG_fail;
37693 swig_obj[0] = args;
37694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37695 if (!SWIG_IsOK(res1)) {
37696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37697 }
37698 arg1 = reinterpret_cast< wxValidator * >(argp1);
37699 {
37700 PyThreadState* __tstate = wxPyBeginAllowThreads();
37701 result = (wxValidator *)(arg1)->Clone();
37702 wxPyEndAllowThreads(__tstate);
37703 if (PyErr_Occurred()) SWIG_fail;
37704 }
37705 {
37706 resultobj = wxPyMake_wxObject(result, 0);
37707 }
37708 return resultobj;
37709 fail:
37710 return NULL;
37711 }
37712
37713
37714 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37715 PyObject *resultobj = 0;
37716 wxValidator *arg1 = (wxValidator *) 0 ;
37717 wxWindow *arg2 = (wxWindow *) 0 ;
37718 bool result;
37719 void *argp1 = 0 ;
37720 int res1 = 0 ;
37721 void *argp2 = 0 ;
37722 int res2 = 0 ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char * kwnames[] = {
37726 (char *) "self",(char *) "parent", NULL
37727 };
37728
37729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37731 if (!SWIG_IsOK(res1)) {
37732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37733 }
37734 arg1 = reinterpret_cast< wxValidator * >(argp1);
37735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37736 if (!SWIG_IsOK(res2)) {
37737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37738 }
37739 arg2 = reinterpret_cast< wxWindow * >(argp2);
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 result = (bool)(arg1)->Validate(arg2);
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 {
37747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37748 }
37749 return resultobj;
37750 fail:
37751 return NULL;
37752 }
37753
37754
37755 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37756 PyObject *resultobj = 0;
37757 wxValidator *arg1 = (wxValidator *) 0 ;
37758 bool result;
37759 void *argp1 = 0 ;
37760 int res1 = 0 ;
37761 PyObject *swig_obj[1] ;
37762
37763 if (!args) SWIG_fail;
37764 swig_obj[0] = args;
37765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37766 if (!SWIG_IsOK(res1)) {
37767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37768 }
37769 arg1 = reinterpret_cast< wxValidator * >(argp1);
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 result = (bool)(arg1)->TransferToWindow();
37773 wxPyEndAllowThreads(__tstate);
37774 if (PyErr_Occurred()) SWIG_fail;
37775 }
37776 {
37777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37778 }
37779 return resultobj;
37780 fail:
37781 return NULL;
37782 }
37783
37784
37785 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37786 PyObject *resultobj = 0;
37787 wxValidator *arg1 = (wxValidator *) 0 ;
37788 bool result;
37789 void *argp1 = 0 ;
37790 int res1 = 0 ;
37791 PyObject *swig_obj[1] ;
37792
37793 if (!args) SWIG_fail;
37794 swig_obj[0] = args;
37795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37796 if (!SWIG_IsOK(res1)) {
37797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37798 }
37799 arg1 = reinterpret_cast< wxValidator * >(argp1);
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 result = (bool)(arg1)->TransferFromWindow();
37803 wxPyEndAllowThreads(__tstate);
37804 if (PyErr_Occurred()) SWIG_fail;
37805 }
37806 {
37807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37808 }
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37816 PyObject *resultobj = 0;
37817 wxValidator *arg1 = (wxValidator *) 0 ;
37818 wxWindow *result = 0 ;
37819 void *argp1 = 0 ;
37820 int res1 = 0 ;
37821 PyObject *swig_obj[1] ;
37822
37823 if (!args) SWIG_fail;
37824 swig_obj[0] = args;
37825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37826 if (!SWIG_IsOK(res1)) {
37827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37828 }
37829 arg1 = reinterpret_cast< wxValidator * >(argp1);
37830 {
37831 PyThreadState* __tstate = wxPyBeginAllowThreads();
37832 result = (wxWindow *)(arg1)->GetWindow();
37833 wxPyEndAllowThreads(__tstate);
37834 if (PyErr_Occurred()) SWIG_fail;
37835 }
37836 {
37837 resultobj = wxPyMake_wxObject(result, 0);
37838 }
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37846 PyObject *resultobj = 0;
37847 wxValidator *arg1 = (wxValidator *) 0 ;
37848 wxWindow *arg2 = (wxWindow *) 0 ;
37849 void *argp1 = 0 ;
37850 int res1 = 0 ;
37851 void *argp2 = 0 ;
37852 int res2 = 0 ;
37853 PyObject * obj0 = 0 ;
37854 PyObject * obj1 = 0 ;
37855 char * kwnames[] = {
37856 (char *) "self",(char *) "window", NULL
37857 };
37858
37859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37861 if (!SWIG_IsOK(res1)) {
37862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37863 }
37864 arg1 = reinterpret_cast< wxValidator * >(argp1);
37865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37866 if (!SWIG_IsOK(res2)) {
37867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37868 }
37869 arg2 = reinterpret_cast< wxWindow * >(argp2);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 (arg1)->SetWindow(arg2);
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_Py_Void();
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37884 PyObject *resultobj = 0;
37885 bool result;
37886
37887 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37888 {
37889 PyThreadState* __tstate = wxPyBeginAllowThreads();
37890 result = (bool)wxValidator::IsSilent();
37891 wxPyEndAllowThreads(__tstate);
37892 if (PyErr_Occurred()) SWIG_fail;
37893 }
37894 {
37895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37896 }
37897 return resultobj;
37898 fail:
37899 return NULL;
37900 }
37901
37902
37903 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37904 PyObject *resultobj = 0;
37905 int arg1 = (int) true ;
37906 int val1 ;
37907 int ecode1 = 0 ;
37908 PyObject * obj0 = 0 ;
37909 char * kwnames[] = {
37910 (char *) "doIt", NULL
37911 };
37912
37913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37914 if (obj0) {
37915 ecode1 = SWIG_AsVal_int(obj0, &val1);
37916 if (!SWIG_IsOK(ecode1)) {
37917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37918 }
37919 arg1 = static_cast< int >(val1);
37920 }
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 wxValidator::SetBellOnError(arg1);
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 resultobj = SWIG_Py_Void();
37928 return resultobj;
37929 fail:
37930 return NULL;
37931 }
37932
37933
37934 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37935 PyObject *obj;
37936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37937 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37938 return SWIG_Py_Void();
37939 }
37940
37941 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37942 return SWIG_Python_InitShadowInstance(args);
37943 }
37944
37945 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37946 PyObject *resultobj = 0;
37947 wxPyValidator *result = 0 ;
37948
37949 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37950 {
37951 PyThreadState* __tstate = wxPyBeginAllowThreads();
37952 result = (wxPyValidator *)new wxPyValidator();
37953 wxPyEndAllowThreads(__tstate);
37954 if (PyErr_Occurred()) SWIG_fail;
37955 }
37956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37957 return resultobj;
37958 fail:
37959 return NULL;
37960 }
37961
37962
37963 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj = 0;
37965 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37966 PyObject *arg2 = (PyObject *) 0 ;
37967 PyObject *arg3 = (PyObject *) 0 ;
37968 int arg4 = (int) true ;
37969 void *argp1 = 0 ;
37970 int res1 = 0 ;
37971 int val4 ;
37972 int ecode4 = 0 ;
37973 PyObject * obj0 = 0 ;
37974 PyObject * obj1 = 0 ;
37975 PyObject * obj2 = 0 ;
37976 PyObject * obj3 = 0 ;
37977 char * kwnames[] = {
37978 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37979 };
37980
37981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37983 if (!SWIG_IsOK(res1)) {
37984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37985 }
37986 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37987 arg2 = obj1;
37988 arg3 = obj2;
37989 if (obj3) {
37990 ecode4 = SWIG_AsVal_int(obj3, &val4);
37991 if (!SWIG_IsOK(ecode4)) {
37992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37993 }
37994 arg4 = static_cast< int >(val4);
37995 }
37996 {
37997 PyThreadState* __tstate = wxPyBeginAllowThreads();
37998 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37999 wxPyEndAllowThreads(__tstate);
38000 if (PyErr_Occurred()) SWIG_fail;
38001 }
38002 resultobj = SWIG_Py_Void();
38003 return resultobj;
38004 fail:
38005 return NULL;
38006 }
38007
38008
38009 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38010 PyObject *obj;
38011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38012 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38013 return SWIG_Py_Void();
38014 }
38015
38016 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38017 return SWIG_Python_InitShadowInstance(args);
38018 }
38019
38020 SWIGINTERN int DefaultValidator_set(PyObject *) {
38021 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38022 return 1;
38023 }
38024
38025
38026 SWIGINTERN PyObject *DefaultValidator_get(void) {
38027 PyObject *pyobj = 0;
38028
38029 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38030 return pyobj;
38031 }
38032
38033
38034 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38035 PyObject *resultobj = 0;
38036 wxString const &arg1_defvalue = wxPyEmptyString ;
38037 wxString *arg1 = (wxString *) &arg1_defvalue ;
38038 long arg2 = (long) 0 ;
38039 wxMenu *result = 0 ;
38040 bool temp1 = false ;
38041 long val2 ;
38042 int ecode2 = 0 ;
38043 PyObject * obj0 = 0 ;
38044 PyObject * obj1 = 0 ;
38045 char * kwnames[] = {
38046 (char *) "title",(char *) "style", NULL
38047 };
38048
38049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38050 if (obj0) {
38051 {
38052 arg1 = wxString_in_helper(obj0);
38053 if (arg1 == NULL) SWIG_fail;
38054 temp1 = true;
38055 }
38056 }
38057 if (obj1) {
38058 ecode2 = SWIG_AsVal_long(obj1, &val2);
38059 if (!SWIG_IsOK(ecode2)) {
38060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38061 }
38062 arg2 = static_cast< long >(val2);
38063 }
38064 {
38065 if (!wxPyCheckForApp()) SWIG_fail;
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38072 {
38073 if (temp1)
38074 delete arg1;
38075 }
38076 return resultobj;
38077 fail:
38078 {
38079 if (temp1)
38080 delete arg1;
38081 }
38082 return NULL;
38083 }
38084
38085
38086 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38087 PyObject *resultobj = 0;
38088 wxMenu *arg1 = (wxMenu *) 0 ;
38089 int arg2 ;
38090 wxString *arg3 = 0 ;
38091 wxString const &arg4_defvalue = wxPyEmptyString ;
38092 wxString *arg4 = (wxString *) &arg4_defvalue ;
38093 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38094 wxMenuItem *result = 0 ;
38095 void *argp1 = 0 ;
38096 int res1 = 0 ;
38097 int val2 ;
38098 int ecode2 = 0 ;
38099 bool temp3 = false ;
38100 bool temp4 = false ;
38101 int val5 ;
38102 int ecode5 = 0 ;
38103 PyObject * obj0 = 0 ;
38104 PyObject * obj1 = 0 ;
38105 PyObject * obj2 = 0 ;
38106 PyObject * obj3 = 0 ;
38107 PyObject * obj4 = 0 ;
38108 char * kwnames[] = {
38109 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38110 };
38111
38112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38114 if (!SWIG_IsOK(res1)) {
38115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38116 }
38117 arg1 = reinterpret_cast< wxMenu * >(argp1);
38118 ecode2 = SWIG_AsVal_int(obj1, &val2);
38119 if (!SWIG_IsOK(ecode2)) {
38120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38121 }
38122 arg2 = static_cast< int >(val2);
38123 {
38124 arg3 = wxString_in_helper(obj2);
38125 if (arg3 == NULL) SWIG_fail;
38126 temp3 = true;
38127 }
38128 if (obj3) {
38129 {
38130 arg4 = wxString_in_helper(obj3);
38131 if (arg4 == NULL) SWIG_fail;
38132 temp4 = true;
38133 }
38134 }
38135 if (obj4) {
38136 ecode5 = SWIG_AsVal_int(obj4, &val5);
38137 if (!SWIG_IsOK(ecode5)) {
38138 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38139 }
38140 arg5 = static_cast< wxItemKind >(val5);
38141 }
38142 {
38143 PyThreadState* __tstate = wxPyBeginAllowThreads();
38144 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38145 wxPyEndAllowThreads(__tstate);
38146 if (PyErr_Occurred()) SWIG_fail;
38147 }
38148 {
38149 resultobj = wxPyMake_wxObject(result, (bool)0);
38150 }
38151 {
38152 if (temp3)
38153 delete arg3;
38154 }
38155 {
38156 if (temp4)
38157 delete arg4;
38158 }
38159 return resultobj;
38160 fail:
38161 {
38162 if (temp3)
38163 delete arg3;
38164 }
38165 {
38166 if (temp4)
38167 delete arg4;
38168 }
38169 return NULL;
38170 }
38171
38172
38173 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38174 PyObject *resultobj = 0;
38175 wxMenu *arg1 = (wxMenu *) 0 ;
38176 wxMenuItem *result = 0 ;
38177 void *argp1 = 0 ;
38178 int res1 = 0 ;
38179 PyObject *swig_obj[1] ;
38180
38181 if (!args) SWIG_fail;
38182 swig_obj[0] = args;
38183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38184 if (!SWIG_IsOK(res1)) {
38185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38186 }
38187 arg1 = reinterpret_cast< wxMenu * >(argp1);
38188 {
38189 PyThreadState* __tstate = wxPyBeginAllowThreads();
38190 result = (wxMenuItem *)(arg1)->AppendSeparator();
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 {
38195 resultobj = wxPyMake_wxObject(result, (bool)0);
38196 }
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38204 PyObject *resultobj = 0;
38205 wxMenu *arg1 = (wxMenu *) 0 ;
38206 int arg2 ;
38207 wxString *arg3 = 0 ;
38208 wxString const &arg4_defvalue = wxPyEmptyString ;
38209 wxString *arg4 = (wxString *) &arg4_defvalue ;
38210 wxMenuItem *result = 0 ;
38211 void *argp1 = 0 ;
38212 int res1 = 0 ;
38213 int val2 ;
38214 int ecode2 = 0 ;
38215 bool temp3 = false ;
38216 bool temp4 = false ;
38217 PyObject * obj0 = 0 ;
38218 PyObject * obj1 = 0 ;
38219 PyObject * obj2 = 0 ;
38220 PyObject * obj3 = 0 ;
38221 char * kwnames[] = {
38222 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38223 };
38224
38225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38227 if (!SWIG_IsOK(res1)) {
38228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38229 }
38230 arg1 = reinterpret_cast< wxMenu * >(argp1);
38231 ecode2 = SWIG_AsVal_int(obj1, &val2);
38232 if (!SWIG_IsOK(ecode2)) {
38233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38234 }
38235 arg2 = static_cast< int >(val2);
38236 {
38237 arg3 = wxString_in_helper(obj2);
38238 if (arg3 == NULL) SWIG_fail;
38239 temp3 = true;
38240 }
38241 if (obj3) {
38242 {
38243 arg4 = wxString_in_helper(obj3);
38244 if (arg4 == NULL) SWIG_fail;
38245 temp4 = true;
38246 }
38247 }
38248 {
38249 PyThreadState* __tstate = wxPyBeginAllowThreads();
38250 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38251 wxPyEndAllowThreads(__tstate);
38252 if (PyErr_Occurred()) SWIG_fail;
38253 }
38254 {
38255 resultobj = wxPyMake_wxObject(result, (bool)0);
38256 }
38257 {
38258 if (temp3)
38259 delete arg3;
38260 }
38261 {
38262 if (temp4)
38263 delete arg4;
38264 }
38265 return resultobj;
38266 fail:
38267 {
38268 if (temp3)
38269 delete arg3;
38270 }
38271 {
38272 if (temp4)
38273 delete arg4;
38274 }
38275 return NULL;
38276 }
38277
38278
38279 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38280 PyObject *resultobj = 0;
38281 wxMenu *arg1 = (wxMenu *) 0 ;
38282 int arg2 ;
38283 wxString *arg3 = 0 ;
38284 wxString const &arg4_defvalue = wxPyEmptyString ;
38285 wxString *arg4 = (wxString *) &arg4_defvalue ;
38286 wxMenuItem *result = 0 ;
38287 void *argp1 = 0 ;
38288 int res1 = 0 ;
38289 int val2 ;
38290 int ecode2 = 0 ;
38291 bool temp3 = false ;
38292 bool temp4 = false ;
38293 PyObject * obj0 = 0 ;
38294 PyObject * obj1 = 0 ;
38295 PyObject * obj2 = 0 ;
38296 PyObject * obj3 = 0 ;
38297 char * kwnames[] = {
38298 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38299 };
38300
38301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38303 if (!SWIG_IsOK(res1)) {
38304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38305 }
38306 arg1 = reinterpret_cast< wxMenu * >(argp1);
38307 ecode2 = SWIG_AsVal_int(obj1, &val2);
38308 if (!SWIG_IsOK(ecode2)) {
38309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38310 }
38311 arg2 = static_cast< int >(val2);
38312 {
38313 arg3 = wxString_in_helper(obj2);
38314 if (arg3 == NULL) SWIG_fail;
38315 temp3 = true;
38316 }
38317 if (obj3) {
38318 {
38319 arg4 = wxString_in_helper(obj3);
38320 if (arg4 == NULL) SWIG_fail;
38321 temp4 = true;
38322 }
38323 }
38324 {
38325 PyThreadState* __tstate = wxPyBeginAllowThreads();
38326 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38327 wxPyEndAllowThreads(__tstate);
38328 if (PyErr_Occurred()) SWIG_fail;
38329 }
38330 {
38331 resultobj = wxPyMake_wxObject(result, (bool)0);
38332 }
38333 {
38334 if (temp3)
38335 delete arg3;
38336 }
38337 {
38338 if (temp4)
38339 delete arg4;
38340 }
38341 return resultobj;
38342 fail:
38343 {
38344 if (temp3)
38345 delete arg3;
38346 }
38347 {
38348 if (temp4)
38349 delete arg4;
38350 }
38351 return NULL;
38352 }
38353
38354
38355 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38356 PyObject *resultobj = 0;
38357 wxMenu *arg1 = (wxMenu *) 0 ;
38358 int arg2 ;
38359 wxString *arg3 = 0 ;
38360 wxMenu *arg4 = (wxMenu *) 0 ;
38361 wxString const &arg5_defvalue = wxPyEmptyString ;
38362 wxString *arg5 = (wxString *) &arg5_defvalue ;
38363 wxMenuItem *result = 0 ;
38364 void *argp1 = 0 ;
38365 int res1 = 0 ;
38366 int val2 ;
38367 int ecode2 = 0 ;
38368 bool temp3 = false ;
38369 void *argp4 = 0 ;
38370 int res4 = 0 ;
38371 bool temp5 = false ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 PyObject * obj3 = 0 ;
38376 PyObject * obj4 = 0 ;
38377 char * kwnames[] = {
38378 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38379 };
38380
38381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 ecode2 = SWIG_AsVal_int(obj1, &val2);
38388 if (!SWIG_IsOK(ecode2)) {
38389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38390 }
38391 arg2 = static_cast< int >(val2);
38392 {
38393 arg3 = wxString_in_helper(obj2);
38394 if (arg3 == NULL) SWIG_fail;
38395 temp3 = true;
38396 }
38397 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38398 if (!SWIG_IsOK(res4)) {
38399 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38400 }
38401 arg4 = reinterpret_cast< wxMenu * >(argp4);
38402 if (obj4) {
38403 {
38404 arg5 = wxString_in_helper(obj4);
38405 if (arg5 == NULL) SWIG_fail;
38406 temp5 = true;
38407 }
38408 }
38409 {
38410 PyThreadState* __tstate = wxPyBeginAllowThreads();
38411 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38412 wxPyEndAllowThreads(__tstate);
38413 if (PyErr_Occurred()) SWIG_fail;
38414 }
38415 {
38416 resultobj = wxPyMake_wxObject(result, (bool)0);
38417 }
38418 {
38419 if (temp3)
38420 delete arg3;
38421 }
38422 {
38423 if (temp5)
38424 delete arg5;
38425 }
38426 return resultobj;
38427 fail:
38428 {
38429 if (temp3)
38430 delete arg3;
38431 }
38432 {
38433 if (temp5)
38434 delete arg5;
38435 }
38436 return NULL;
38437 }
38438
38439
38440 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38441 PyObject *resultobj = 0;
38442 wxMenu *arg1 = (wxMenu *) 0 ;
38443 wxMenu *arg2 = (wxMenu *) 0 ;
38444 wxString *arg3 = 0 ;
38445 wxString const &arg4_defvalue = wxPyEmptyString ;
38446 wxString *arg4 = (wxString *) &arg4_defvalue ;
38447 wxMenuItem *result = 0 ;
38448 void *argp1 = 0 ;
38449 int res1 = 0 ;
38450 void *argp2 = 0 ;
38451 int res2 = 0 ;
38452 bool temp3 = false ;
38453 bool temp4 = false ;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 PyObject * obj2 = 0 ;
38457 PyObject * obj3 = 0 ;
38458 char * kwnames[] = {
38459 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38460 };
38461
38462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38464 if (!SWIG_IsOK(res1)) {
38465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38466 }
38467 arg1 = reinterpret_cast< wxMenu * >(argp1);
38468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38469 if (!SWIG_IsOK(res2)) {
38470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38471 }
38472 arg2 = reinterpret_cast< wxMenu * >(argp2);
38473 {
38474 arg3 = wxString_in_helper(obj2);
38475 if (arg3 == NULL) SWIG_fail;
38476 temp3 = true;
38477 }
38478 if (obj3) {
38479 {
38480 arg4 = wxString_in_helper(obj3);
38481 if (arg4 == NULL) SWIG_fail;
38482 temp4 = true;
38483 }
38484 }
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38488 wxPyEndAllowThreads(__tstate);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 }
38491 {
38492 resultobj = wxPyMake_wxObject(result, (bool)0);
38493 }
38494 {
38495 if (temp3)
38496 delete arg3;
38497 }
38498 {
38499 if (temp4)
38500 delete arg4;
38501 }
38502 return resultobj;
38503 fail:
38504 {
38505 if (temp3)
38506 delete arg3;
38507 }
38508 {
38509 if (temp4)
38510 delete arg4;
38511 }
38512 return NULL;
38513 }
38514
38515
38516 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38517 PyObject *resultobj = 0;
38518 wxMenu *arg1 = (wxMenu *) 0 ;
38519 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38520 wxMenuItem *result = 0 ;
38521 void *argp1 = 0 ;
38522 int res1 = 0 ;
38523 int res2 = 0 ;
38524 PyObject * obj0 = 0 ;
38525 PyObject * obj1 = 0 ;
38526 char * kwnames[] = {
38527 (char *) "self",(char *) "item", NULL
38528 };
38529
38530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38532 if (!SWIG_IsOK(res1)) {
38533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38534 }
38535 arg1 = reinterpret_cast< wxMenu * >(argp1);
38536 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38537 if (!SWIG_IsOK(res2)) {
38538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38539 }
38540 {
38541 PyThreadState* __tstate = wxPyBeginAllowThreads();
38542 result = (wxMenuItem *)(arg1)->Append(arg2);
38543 wxPyEndAllowThreads(__tstate);
38544 if (PyErr_Occurred()) SWIG_fail;
38545 }
38546 {
38547 resultobj = wxPyMake_wxObject(result, (bool)0);
38548 }
38549 return resultobj;
38550 fail:
38551 return NULL;
38552 }
38553
38554
38555 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38556 PyObject *resultobj = 0;
38557 wxMenu *arg1 = (wxMenu *) 0 ;
38558 size_t arg2 ;
38559 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38560 wxMenuItem *result = 0 ;
38561 void *argp1 = 0 ;
38562 int res1 = 0 ;
38563 size_t val2 ;
38564 int ecode2 = 0 ;
38565 int res3 = 0 ;
38566 PyObject * obj0 = 0 ;
38567 PyObject * obj1 = 0 ;
38568 PyObject * obj2 = 0 ;
38569 char * kwnames[] = {
38570 (char *) "self",(char *) "pos",(char *) "item", NULL
38571 };
38572
38573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38575 if (!SWIG_IsOK(res1)) {
38576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38577 }
38578 arg1 = reinterpret_cast< wxMenu * >(argp1);
38579 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38580 if (!SWIG_IsOK(ecode2)) {
38581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38582 }
38583 arg2 = static_cast< size_t >(val2);
38584 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38585 if (!SWIG_IsOK(res3)) {
38586 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38587 }
38588 {
38589 PyThreadState* __tstate = wxPyBeginAllowThreads();
38590 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38591 wxPyEndAllowThreads(__tstate);
38592 if (PyErr_Occurred()) SWIG_fail;
38593 }
38594 {
38595 resultobj = wxPyMake_wxObject(result, (bool)0);
38596 }
38597 return resultobj;
38598 fail:
38599 return NULL;
38600 }
38601
38602
38603 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38604 PyObject *resultobj = 0;
38605 wxMenu *arg1 = (wxMenu *) 0 ;
38606 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38607 wxMenuItem *result = 0 ;
38608 void *argp1 = 0 ;
38609 int res1 = 0 ;
38610 int res2 = 0 ;
38611 PyObject * obj0 = 0 ;
38612 PyObject * obj1 = 0 ;
38613 char * kwnames[] = {
38614 (char *) "self",(char *) "item", NULL
38615 };
38616
38617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38619 if (!SWIG_IsOK(res1)) {
38620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38621 }
38622 arg1 = reinterpret_cast< wxMenu * >(argp1);
38623 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38624 if (!SWIG_IsOK(res2)) {
38625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38626 }
38627 {
38628 PyThreadState* __tstate = wxPyBeginAllowThreads();
38629 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38630 wxPyEndAllowThreads(__tstate);
38631 if (PyErr_Occurred()) SWIG_fail;
38632 }
38633 {
38634 resultobj = wxPyMake_wxObject(result, (bool)0);
38635 }
38636 return resultobj;
38637 fail:
38638 return NULL;
38639 }
38640
38641
38642 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38643 PyObject *resultobj = 0;
38644 wxMenu *arg1 = (wxMenu *) 0 ;
38645 void *argp1 = 0 ;
38646 int res1 = 0 ;
38647 PyObject *swig_obj[1] ;
38648
38649 if (!args) SWIG_fail;
38650 swig_obj[0] = args;
38651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38652 if (!SWIG_IsOK(res1)) {
38653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38654 }
38655 arg1 = reinterpret_cast< wxMenu * >(argp1);
38656 {
38657 PyThreadState* __tstate = wxPyBeginAllowThreads();
38658 (arg1)->Break();
38659 wxPyEndAllowThreads(__tstate);
38660 if (PyErr_Occurred()) SWIG_fail;
38661 }
38662 resultobj = SWIG_Py_Void();
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38670 PyObject *resultobj = 0;
38671 wxMenu *arg1 = (wxMenu *) 0 ;
38672 size_t arg2 ;
38673 int arg3 ;
38674 wxString *arg4 = 0 ;
38675 wxString const &arg5_defvalue = wxPyEmptyString ;
38676 wxString *arg5 = (wxString *) &arg5_defvalue ;
38677 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38678 wxMenuItem *result = 0 ;
38679 void *argp1 = 0 ;
38680 int res1 = 0 ;
38681 size_t val2 ;
38682 int ecode2 = 0 ;
38683 int val3 ;
38684 int ecode3 = 0 ;
38685 bool temp4 = false ;
38686 bool temp5 = false ;
38687 int val6 ;
38688 int ecode6 = 0 ;
38689 PyObject * obj0 = 0 ;
38690 PyObject * obj1 = 0 ;
38691 PyObject * obj2 = 0 ;
38692 PyObject * obj3 = 0 ;
38693 PyObject * obj4 = 0 ;
38694 PyObject * obj5 = 0 ;
38695 char * kwnames[] = {
38696 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38697 };
38698
38699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38701 if (!SWIG_IsOK(res1)) {
38702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38703 }
38704 arg1 = reinterpret_cast< wxMenu * >(argp1);
38705 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38706 if (!SWIG_IsOK(ecode2)) {
38707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38708 }
38709 arg2 = static_cast< size_t >(val2);
38710 ecode3 = SWIG_AsVal_int(obj2, &val3);
38711 if (!SWIG_IsOK(ecode3)) {
38712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38713 }
38714 arg3 = static_cast< int >(val3);
38715 {
38716 arg4 = wxString_in_helper(obj3);
38717 if (arg4 == NULL) SWIG_fail;
38718 temp4 = true;
38719 }
38720 if (obj4) {
38721 {
38722 arg5 = wxString_in_helper(obj4);
38723 if (arg5 == NULL) SWIG_fail;
38724 temp5 = true;
38725 }
38726 }
38727 if (obj5) {
38728 ecode6 = SWIG_AsVal_int(obj5, &val6);
38729 if (!SWIG_IsOK(ecode6)) {
38730 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38731 }
38732 arg6 = static_cast< wxItemKind >(val6);
38733 }
38734 {
38735 PyThreadState* __tstate = wxPyBeginAllowThreads();
38736 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38737 wxPyEndAllowThreads(__tstate);
38738 if (PyErr_Occurred()) SWIG_fail;
38739 }
38740 {
38741 resultobj = wxPyMake_wxObject(result, (bool)0);
38742 }
38743 {
38744 if (temp4)
38745 delete arg4;
38746 }
38747 {
38748 if (temp5)
38749 delete arg5;
38750 }
38751 return resultobj;
38752 fail:
38753 {
38754 if (temp4)
38755 delete arg4;
38756 }
38757 {
38758 if (temp5)
38759 delete arg5;
38760 }
38761 return NULL;
38762 }
38763
38764
38765 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38766 PyObject *resultobj = 0;
38767 wxMenu *arg1 = (wxMenu *) 0 ;
38768 size_t arg2 ;
38769 wxMenuItem *result = 0 ;
38770 void *argp1 = 0 ;
38771 int res1 = 0 ;
38772 size_t val2 ;
38773 int ecode2 = 0 ;
38774 PyObject * obj0 = 0 ;
38775 PyObject * obj1 = 0 ;
38776 char * kwnames[] = {
38777 (char *) "self",(char *) "pos", NULL
38778 };
38779
38780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38782 if (!SWIG_IsOK(res1)) {
38783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38784 }
38785 arg1 = reinterpret_cast< wxMenu * >(argp1);
38786 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38787 if (!SWIG_IsOK(ecode2)) {
38788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38789 }
38790 arg2 = static_cast< size_t >(val2);
38791 {
38792 PyThreadState* __tstate = wxPyBeginAllowThreads();
38793 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38794 wxPyEndAllowThreads(__tstate);
38795 if (PyErr_Occurred()) SWIG_fail;
38796 }
38797 {
38798 resultobj = wxPyMake_wxObject(result, (bool)0);
38799 }
38800 return resultobj;
38801 fail:
38802 return NULL;
38803 }
38804
38805
38806 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38807 PyObject *resultobj = 0;
38808 wxMenu *arg1 = (wxMenu *) 0 ;
38809 size_t arg2 ;
38810 int arg3 ;
38811 wxString *arg4 = 0 ;
38812 wxString const &arg5_defvalue = wxPyEmptyString ;
38813 wxString *arg5 = (wxString *) &arg5_defvalue ;
38814 wxMenuItem *result = 0 ;
38815 void *argp1 = 0 ;
38816 int res1 = 0 ;
38817 size_t val2 ;
38818 int ecode2 = 0 ;
38819 int val3 ;
38820 int ecode3 = 0 ;
38821 bool temp4 = false ;
38822 bool temp5 = false ;
38823 PyObject * obj0 = 0 ;
38824 PyObject * obj1 = 0 ;
38825 PyObject * obj2 = 0 ;
38826 PyObject * obj3 = 0 ;
38827 PyObject * obj4 = 0 ;
38828 char * kwnames[] = {
38829 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38830 };
38831
38832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38834 if (!SWIG_IsOK(res1)) {
38835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38836 }
38837 arg1 = reinterpret_cast< wxMenu * >(argp1);
38838 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38839 if (!SWIG_IsOK(ecode2)) {
38840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38841 }
38842 arg2 = static_cast< size_t >(val2);
38843 ecode3 = SWIG_AsVal_int(obj2, &val3);
38844 if (!SWIG_IsOK(ecode3)) {
38845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38846 }
38847 arg3 = static_cast< int >(val3);
38848 {
38849 arg4 = wxString_in_helper(obj3);
38850 if (arg4 == NULL) SWIG_fail;
38851 temp4 = true;
38852 }
38853 if (obj4) {
38854 {
38855 arg5 = wxString_in_helper(obj4);
38856 if (arg5 == NULL) SWIG_fail;
38857 temp5 = true;
38858 }
38859 }
38860 {
38861 PyThreadState* __tstate = wxPyBeginAllowThreads();
38862 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38863 wxPyEndAllowThreads(__tstate);
38864 if (PyErr_Occurred()) SWIG_fail;
38865 }
38866 {
38867 resultobj = wxPyMake_wxObject(result, (bool)0);
38868 }
38869 {
38870 if (temp4)
38871 delete arg4;
38872 }
38873 {
38874 if (temp5)
38875 delete arg5;
38876 }
38877 return resultobj;
38878 fail:
38879 {
38880 if (temp4)
38881 delete arg4;
38882 }
38883 {
38884 if (temp5)
38885 delete arg5;
38886 }
38887 return NULL;
38888 }
38889
38890
38891 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38892 PyObject *resultobj = 0;
38893 wxMenu *arg1 = (wxMenu *) 0 ;
38894 size_t arg2 ;
38895 int arg3 ;
38896 wxString *arg4 = 0 ;
38897 wxString const &arg5_defvalue = wxPyEmptyString ;
38898 wxString *arg5 = (wxString *) &arg5_defvalue ;
38899 wxMenuItem *result = 0 ;
38900 void *argp1 = 0 ;
38901 int res1 = 0 ;
38902 size_t val2 ;
38903 int ecode2 = 0 ;
38904 int val3 ;
38905 int ecode3 = 0 ;
38906 bool temp4 = false ;
38907 bool temp5 = false ;
38908 PyObject * obj0 = 0 ;
38909 PyObject * obj1 = 0 ;
38910 PyObject * obj2 = 0 ;
38911 PyObject * obj3 = 0 ;
38912 PyObject * obj4 = 0 ;
38913 char * kwnames[] = {
38914 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38915 };
38916
38917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38919 if (!SWIG_IsOK(res1)) {
38920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38921 }
38922 arg1 = reinterpret_cast< wxMenu * >(argp1);
38923 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38924 if (!SWIG_IsOK(ecode2)) {
38925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38926 }
38927 arg2 = static_cast< size_t >(val2);
38928 ecode3 = SWIG_AsVal_int(obj2, &val3);
38929 if (!SWIG_IsOK(ecode3)) {
38930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38931 }
38932 arg3 = static_cast< int >(val3);
38933 {
38934 arg4 = wxString_in_helper(obj3);
38935 if (arg4 == NULL) SWIG_fail;
38936 temp4 = true;
38937 }
38938 if (obj4) {
38939 {
38940 arg5 = wxString_in_helper(obj4);
38941 if (arg5 == NULL) SWIG_fail;
38942 temp5 = true;
38943 }
38944 }
38945 {
38946 PyThreadState* __tstate = wxPyBeginAllowThreads();
38947 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38948 wxPyEndAllowThreads(__tstate);
38949 if (PyErr_Occurred()) SWIG_fail;
38950 }
38951 {
38952 resultobj = wxPyMake_wxObject(result, (bool)0);
38953 }
38954 {
38955 if (temp4)
38956 delete arg4;
38957 }
38958 {
38959 if (temp5)
38960 delete arg5;
38961 }
38962 return resultobj;
38963 fail:
38964 {
38965 if (temp4)
38966 delete arg4;
38967 }
38968 {
38969 if (temp5)
38970 delete arg5;
38971 }
38972 return NULL;
38973 }
38974
38975
38976 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38977 PyObject *resultobj = 0;
38978 wxMenu *arg1 = (wxMenu *) 0 ;
38979 size_t arg2 ;
38980 int arg3 ;
38981 wxString *arg4 = 0 ;
38982 wxMenu *arg5 = (wxMenu *) 0 ;
38983 wxString const &arg6_defvalue = wxPyEmptyString ;
38984 wxString *arg6 = (wxString *) &arg6_defvalue ;
38985 wxMenuItem *result = 0 ;
38986 void *argp1 = 0 ;
38987 int res1 = 0 ;
38988 size_t val2 ;
38989 int ecode2 = 0 ;
38990 int val3 ;
38991 int ecode3 = 0 ;
38992 bool temp4 = false ;
38993 void *argp5 = 0 ;
38994 int res5 = 0 ;
38995 bool temp6 = false ;
38996 PyObject * obj0 = 0 ;
38997 PyObject * obj1 = 0 ;
38998 PyObject * obj2 = 0 ;
38999 PyObject * obj3 = 0 ;
39000 PyObject * obj4 = 0 ;
39001 PyObject * obj5 = 0 ;
39002 char * kwnames[] = {
39003 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39004 };
39005
39006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39008 if (!SWIG_IsOK(res1)) {
39009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39010 }
39011 arg1 = reinterpret_cast< wxMenu * >(argp1);
39012 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39013 if (!SWIG_IsOK(ecode2)) {
39014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39015 }
39016 arg2 = static_cast< size_t >(val2);
39017 ecode3 = SWIG_AsVal_int(obj2, &val3);
39018 if (!SWIG_IsOK(ecode3)) {
39019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39020 }
39021 arg3 = static_cast< int >(val3);
39022 {
39023 arg4 = wxString_in_helper(obj3);
39024 if (arg4 == NULL) SWIG_fail;
39025 temp4 = true;
39026 }
39027 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39028 if (!SWIG_IsOK(res5)) {
39029 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39030 }
39031 arg5 = reinterpret_cast< wxMenu * >(argp5);
39032 if (obj5) {
39033 {
39034 arg6 = wxString_in_helper(obj5);
39035 if (arg6 == NULL) SWIG_fail;
39036 temp6 = true;
39037 }
39038 }
39039 {
39040 PyThreadState* __tstate = wxPyBeginAllowThreads();
39041 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39042 wxPyEndAllowThreads(__tstate);
39043 if (PyErr_Occurred()) SWIG_fail;
39044 }
39045 {
39046 resultobj = wxPyMake_wxObject(result, (bool)0);
39047 }
39048 {
39049 if (temp4)
39050 delete arg4;
39051 }
39052 {
39053 if (temp6)
39054 delete arg6;
39055 }
39056 return resultobj;
39057 fail:
39058 {
39059 if (temp4)
39060 delete arg4;
39061 }
39062 {
39063 if (temp6)
39064 delete arg6;
39065 }
39066 return NULL;
39067 }
39068
39069
39070 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39071 PyObject *resultobj = 0;
39072 wxMenu *arg1 = (wxMenu *) 0 ;
39073 int arg2 ;
39074 wxString *arg3 = 0 ;
39075 wxString const &arg4_defvalue = wxPyEmptyString ;
39076 wxString *arg4 = (wxString *) &arg4_defvalue ;
39077 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39078 wxMenuItem *result = 0 ;
39079 void *argp1 = 0 ;
39080 int res1 = 0 ;
39081 int val2 ;
39082 int ecode2 = 0 ;
39083 bool temp3 = false ;
39084 bool temp4 = false ;
39085 int val5 ;
39086 int ecode5 = 0 ;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 PyObject * obj2 = 0 ;
39090 PyObject * obj3 = 0 ;
39091 PyObject * obj4 = 0 ;
39092 char * kwnames[] = {
39093 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39094 };
39095
39096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39098 if (!SWIG_IsOK(res1)) {
39099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39100 }
39101 arg1 = reinterpret_cast< wxMenu * >(argp1);
39102 ecode2 = SWIG_AsVal_int(obj1, &val2);
39103 if (!SWIG_IsOK(ecode2)) {
39104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39105 }
39106 arg2 = static_cast< int >(val2);
39107 {
39108 arg3 = wxString_in_helper(obj2);
39109 if (arg3 == NULL) SWIG_fail;
39110 temp3 = true;
39111 }
39112 if (obj3) {
39113 {
39114 arg4 = wxString_in_helper(obj3);
39115 if (arg4 == NULL) SWIG_fail;
39116 temp4 = true;
39117 }
39118 }
39119 if (obj4) {
39120 ecode5 = SWIG_AsVal_int(obj4, &val5);
39121 if (!SWIG_IsOK(ecode5)) {
39122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39123 }
39124 arg5 = static_cast< wxItemKind >(val5);
39125 }
39126 {
39127 PyThreadState* __tstate = wxPyBeginAllowThreads();
39128 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39129 wxPyEndAllowThreads(__tstate);
39130 if (PyErr_Occurred()) SWIG_fail;
39131 }
39132 {
39133 resultobj = wxPyMake_wxObject(result, (bool)0);
39134 }
39135 {
39136 if (temp3)
39137 delete arg3;
39138 }
39139 {
39140 if (temp4)
39141 delete arg4;
39142 }
39143 return resultobj;
39144 fail:
39145 {
39146 if (temp3)
39147 delete arg3;
39148 }
39149 {
39150 if (temp4)
39151 delete arg4;
39152 }
39153 return NULL;
39154 }
39155
39156
39157 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39158 PyObject *resultobj = 0;
39159 wxMenu *arg1 = (wxMenu *) 0 ;
39160 wxMenuItem *result = 0 ;
39161 void *argp1 = 0 ;
39162 int res1 = 0 ;
39163 PyObject *swig_obj[1] ;
39164
39165 if (!args) SWIG_fail;
39166 swig_obj[0] = args;
39167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39168 if (!SWIG_IsOK(res1)) {
39169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39170 }
39171 arg1 = reinterpret_cast< wxMenu * >(argp1);
39172 {
39173 PyThreadState* __tstate = wxPyBeginAllowThreads();
39174 result = (wxMenuItem *)(arg1)->PrependSeparator();
39175 wxPyEndAllowThreads(__tstate);
39176 if (PyErr_Occurred()) SWIG_fail;
39177 }
39178 {
39179 resultobj = wxPyMake_wxObject(result, (bool)0);
39180 }
39181 return resultobj;
39182 fail:
39183 return NULL;
39184 }
39185
39186
39187 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39188 PyObject *resultobj = 0;
39189 wxMenu *arg1 = (wxMenu *) 0 ;
39190 int arg2 ;
39191 wxString *arg3 = 0 ;
39192 wxString const &arg4_defvalue = wxPyEmptyString ;
39193 wxString *arg4 = (wxString *) &arg4_defvalue ;
39194 wxMenuItem *result = 0 ;
39195 void *argp1 = 0 ;
39196 int res1 = 0 ;
39197 int val2 ;
39198 int ecode2 = 0 ;
39199 bool temp3 = false ;
39200 bool temp4 = false ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 PyObject * obj2 = 0 ;
39204 PyObject * obj3 = 0 ;
39205 char * kwnames[] = {
39206 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39207 };
39208
39209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39211 if (!SWIG_IsOK(res1)) {
39212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39213 }
39214 arg1 = reinterpret_cast< wxMenu * >(argp1);
39215 ecode2 = SWIG_AsVal_int(obj1, &val2);
39216 if (!SWIG_IsOK(ecode2)) {
39217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39218 }
39219 arg2 = static_cast< int >(val2);
39220 {
39221 arg3 = wxString_in_helper(obj2);
39222 if (arg3 == NULL) SWIG_fail;
39223 temp3 = true;
39224 }
39225 if (obj3) {
39226 {
39227 arg4 = wxString_in_helper(obj3);
39228 if (arg4 == NULL) SWIG_fail;
39229 temp4 = true;
39230 }
39231 }
39232 {
39233 PyThreadState* __tstate = wxPyBeginAllowThreads();
39234 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39235 wxPyEndAllowThreads(__tstate);
39236 if (PyErr_Occurred()) SWIG_fail;
39237 }
39238 {
39239 resultobj = wxPyMake_wxObject(result, (bool)0);
39240 }
39241 {
39242 if (temp3)
39243 delete arg3;
39244 }
39245 {
39246 if (temp4)
39247 delete arg4;
39248 }
39249 return resultobj;
39250 fail:
39251 {
39252 if (temp3)
39253 delete arg3;
39254 }
39255 {
39256 if (temp4)
39257 delete arg4;
39258 }
39259 return NULL;
39260 }
39261
39262
39263 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj = 0;
39265 wxMenu *arg1 = (wxMenu *) 0 ;
39266 int arg2 ;
39267 wxString *arg3 = 0 ;
39268 wxString const &arg4_defvalue = wxPyEmptyString ;
39269 wxString *arg4 = (wxString *) &arg4_defvalue ;
39270 wxMenuItem *result = 0 ;
39271 void *argp1 = 0 ;
39272 int res1 = 0 ;
39273 int val2 ;
39274 int ecode2 = 0 ;
39275 bool temp3 = false ;
39276 bool temp4 = false ;
39277 PyObject * obj0 = 0 ;
39278 PyObject * obj1 = 0 ;
39279 PyObject * obj2 = 0 ;
39280 PyObject * obj3 = 0 ;
39281 char * kwnames[] = {
39282 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39283 };
39284
39285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39287 if (!SWIG_IsOK(res1)) {
39288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39289 }
39290 arg1 = reinterpret_cast< wxMenu * >(argp1);
39291 ecode2 = SWIG_AsVal_int(obj1, &val2);
39292 if (!SWIG_IsOK(ecode2)) {
39293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39294 }
39295 arg2 = static_cast< int >(val2);
39296 {
39297 arg3 = wxString_in_helper(obj2);
39298 if (arg3 == NULL) SWIG_fail;
39299 temp3 = true;
39300 }
39301 if (obj3) {
39302 {
39303 arg4 = wxString_in_helper(obj3);
39304 if (arg4 == NULL) SWIG_fail;
39305 temp4 = true;
39306 }
39307 }
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 {
39315 resultobj = wxPyMake_wxObject(result, (bool)0);
39316 }
39317 {
39318 if (temp3)
39319 delete arg3;
39320 }
39321 {
39322 if (temp4)
39323 delete arg4;
39324 }
39325 return resultobj;
39326 fail:
39327 {
39328 if (temp3)
39329 delete arg3;
39330 }
39331 {
39332 if (temp4)
39333 delete arg4;
39334 }
39335 return NULL;
39336 }
39337
39338
39339 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj = 0;
39341 wxMenu *arg1 = (wxMenu *) 0 ;
39342 int arg2 ;
39343 wxString *arg3 = 0 ;
39344 wxMenu *arg4 = (wxMenu *) 0 ;
39345 wxString const &arg5_defvalue = wxPyEmptyString ;
39346 wxString *arg5 = (wxString *) &arg5_defvalue ;
39347 wxMenuItem *result = 0 ;
39348 void *argp1 = 0 ;
39349 int res1 = 0 ;
39350 int val2 ;
39351 int ecode2 = 0 ;
39352 bool temp3 = false ;
39353 void *argp4 = 0 ;
39354 int res4 = 0 ;
39355 bool temp5 = false ;
39356 PyObject * obj0 = 0 ;
39357 PyObject * obj1 = 0 ;
39358 PyObject * obj2 = 0 ;
39359 PyObject * obj3 = 0 ;
39360 PyObject * obj4 = 0 ;
39361 char * kwnames[] = {
39362 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39363 };
39364
39365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39367 if (!SWIG_IsOK(res1)) {
39368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39369 }
39370 arg1 = reinterpret_cast< wxMenu * >(argp1);
39371 ecode2 = SWIG_AsVal_int(obj1, &val2);
39372 if (!SWIG_IsOK(ecode2)) {
39373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39374 }
39375 arg2 = static_cast< int >(val2);
39376 {
39377 arg3 = wxString_in_helper(obj2);
39378 if (arg3 == NULL) SWIG_fail;
39379 temp3 = true;
39380 }
39381 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39382 if (!SWIG_IsOK(res4)) {
39383 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39384 }
39385 arg4 = reinterpret_cast< wxMenu * >(argp4);
39386 if (obj4) {
39387 {
39388 arg5 = wxString_in_helper(obj4);
39389 if (arg5 == NULL) SWIG_fail;
39390 temp5 = true;
39391 }
39392 }
39393 {
39394 PyThreadState* __tstate = wxPyBeginAllowThreads();
39395 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39396 wxPyEndAllowThreads(__tstate);
39397 if (PyErr_Occurred()) SWIG_fail;
39398 }
39399 {
39400 resultobj = wxPyMake_wxObject(result, (bool)0);
39401 }
39402 {
39403 if (temp3)
39404 delete arg3;
39405 }
39406 {
39407 if (temp5)
39408 delete arg5;
39409 }
39410 return resultobj;
39411 fail:
39412 {
39413 if (temp3)
39414 delete arg3;
39415 }
39416 {
39417 if (temp5)
39418 delete arg5;
39419 }
39420 return NULL;
39421 }
39422
39423
39424 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39425 PyObject *resultobj = 0;
39426 wxMenu *arg1 = (wxMenu *) 0 ;
39427 int arg2 ;
39428 wxMenuItem *result = 0 ;
39429 void *argp1 = 0 ;
39430 int res1 = 0 ;
39431 int val2 ;
39432 int ecode2 = 0 ;
39433 PyObject * obj0 = 0 ;
39434 PyObject * obj1 = 0 ;
39435 char * kwnames[] = {
39436 (char *) "self",(char *) "id", NULL
39437 };
39438
39439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39441 if (!SWIG_IsOK(res1)) {
39442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39443 }
39444 arg1 = reinterpret_cast< wxMenu * >(argp1);
39445 ecode2 = SWIG_AsVal_int(obj1, &val2);
39446 if (!SWIG_IsOK(ecode2)) {
39447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39448 }
39449 arg2 = static_cast< int >(val2);
39450 {
39451 PyThreadState* __tstate = wxPyBeginAllowThreads();
39452 result = (wxMenuItem *)(arg1)->Remove(arg2);
39453 wxPyEndAllowThreads(__tstate);
39454 if (PyErr_Occurred()) SWIG_fail;
39455 }
39456 {
39457 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39458 }
39459 return resultobj;
39460 fail:
39461 return NULL;
39462 }
39463
39464
39465 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39466 PyObject *resultobj = 0;
39467 wxMenu *arg1 = (wxMenu *) 0 ;
39468 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39469 wxMenuItem *result = 0 ;
39470 void *argp1 = 0 ;
39471 int res1 = 0 ;
39472 void *argp2 = 0 ;
39473 int res2 = 0 ;
39474 PyObject * obj0 = 0 ;
39475 PyObject * obj1 = 0 ;
39476 char * kwnames[] = {
39477 (char *) "self",(char *) "item", NULL
39478 };
39479
39480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39482 if (!SWIG_IsOK(res1)) {
39483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39484 }
39485 arg1 = reinterpret_cast< wxMenu * >(argp1);
39486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39487 if (!SWIG_IsOK(res2)) {
39488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39489 }
39490 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 result = (wxMenuItem *)(arg1)->Remove(arg2);
39494 wxPyEndAllowThreads(__tstate);
39495 if (PyErr_Occurred()) SWIG_fail;
39496 }
39497 {
39498 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39499 }
39500 return resultobj;
39501 fail:
39502 return NULL;
39503 }
39504
39505
39506 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39507 PyObject *resultobj = 0;
39508 wxMenu *arg1 = (wxMenu *) 0 ;
39509 int arg2 ;
39510 bool result;
39511 void *argp1 = 0 ;
39512 int res1 = 0 ;
39513 int val2 ;
39514 int ecode2 = 0 ;
39515 PyObject * obj0 = 0 ;
39516 PyObject * obj1 = 0 ;
39517 char * kwnames[] = {
39518 (char *) "self",(char *) "id", NULL
39519 };
39520
39521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39523 if (!SWIG_IsOK(res1)) {
39524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39525 }
39526 arg1 = reinterpret_cast< wxMenu * >(argp1);
39527 ecode2 = SWIG_AsVal_int(obj1, &val2);
39528 if (!SWIG_IsOK(ecode2)) {
39529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39530 }
39531 arg2 = static_cast< int >(val2);
39532 {
39533 PyThreadState* __tstate = wxPyBeginAllowThreads();
39534 result = (bool)(arg1)->Delete(arg2);
39535 wxPyEndAllowThreads(__tstate);
39536 if (PyErr_Occurred()) SWIG_fail;
39537 }
39538 {
39539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39540 }
39541 return resultobj;
39542 fail:
39543 return NULL;
39544 }
39545
39546
39547 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39548 PyObject *resultobj = 0;
39549 wxMenu *arg1 = (wxMenu *) 0 ;
39550 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39551 bool result;
39552 void *argp1 = 0 ;
39553 int res1 = 0 ;
39554 void *argp2 = 0 ;
39555 int res2 = 0 ;
39556 PyObject * obj0 = 0 ;
39557 PyObject * obj1 = 0 ;
39558 char * kwnames[] = {
39559 (char *) "self",(char *) "item", NULL
39560 };
39561
39562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39564 if (!SWIG_IsOK(res1)) {
39565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39566 }
39567 arg1 = reinterpret_cast< wxMenu * >(argp1);
39568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39569 if (!SWIG_IsOK(res2)) {
39570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39571 }
39572 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39573 {
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 result = (bool)(arg1)->Delete(arg2);
39576 wxPyEndAllowThreads(__tstate);
39577 if (PyErr_Occurred()) SWIG_fail;
39578 }
39579 {
39580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39581 }
39582 return resultobj;
39583 fail:
39584 return NULL;
39585 }
39586
39587
39588 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39589 PyObject *resultobj = 0;
39590 wxMenu *arg1 = (wxMenu *) 0 ;
39591 void *argp1 = 0 ;
39592 int res1 = 0 ;
39593 PyObject *swig_obj[1] ;
39594
39595 if (!args) SWIG_fail;
39596 swig_obj[0] = args;
39597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39598 if (!SWIG_IsOK(res1)) {
39599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39600 }
39601 arg1 = reinterpret_cast< wxMenu * >(argp1);
39602 {
39603 PyThreadState* __tstate = wxPyBeginAllowThreads();
39604 wxMenu_Destroy(arg1);
39605 wxPyEndAllowThreads(__tstate);
39606 if (PyErr_Occurred()) SWIG_fail;
39607 }
39608 resultobj = SWIG_Py_Void();
39609 return resultobj;
39610 fail:
39611 return NULL;
39612 }
39613
39614
39615 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39616 PyObject *resultobj = 0;
39617 wxMenu *arg1 = (wxMenu *) 0 ;
39618 int arg2 ;
39619 bool result;
39620 void *argp1 = 0 ;
39621 int res1 = 0 ;
39622 int val2 ;
39623 int ecode2 = 0 ;
39624 PyObject * obj0 = 0 ;
39625 PyObject * obj1 = 0 ;
39626 char * kwnames[] = {
39627 (char *) "self",(char *) "id", NULL
39628 };
39629
39630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39632 if (!SWIG_IsOK(res1)) {
39633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39634 }
39635 arg1 = reinterpret_cast< wxMenu * >(argp1);
39636 ecode2 = SWIG_AsVal_int(obj1, &val2);
39637 if (!SWIG_IsOK(ecode2)) {
39638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39639 }
39640 arg2 = static_cast< int >(val2);
39641 {
39642 PyThreadState* __tstate = wxPyBeginAllowThreads();
39643 result = (bool)(arg1)->Destroy(arg2);
39644 wxPyEndAllowThreads(__tstate);
39645 if (PyErr_Occurred()) SWIG_fail;
39646 }
39647 {
39648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39649 }
39650 return resultobj;
39651 fail:
39652 return NULL;
39653 }
39654
39655
39656 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj = 0;
39658 wxMenu *arg1 = (wxMenu *) 0 ;
39659 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39660 bool result;
39661 void *argp1 = 0 ;
39662 int res1 = 0 ;
39663 void *argp2 = 0 ;
39664 int res2 = 0 ;
39665 PyObject * obj0 = 0 ;
39666 PyObject * obj1 = 0 ;
39667 char * kwnames[] = {
39668 (char *) "self",(char *) "item", NULL
39669 };
39670
39671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39673 if (!SWIG_IsOK(res1)) {
39674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39675 }
39676 arg1 = reinterpret_cast< wxMenu * >(argp1);
39677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39678 if (!SWIG_IsOK(res2)) {
39679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39680 }
39681 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39682 {
39683 PyThreadState* __tstate = wxPyBeginAllowThreads();
39684 result = (bool)(arg1)->Destroy(arg2);
39685 wxPyEndAllowThreads(__tstate);
39686 if (PyErr_Occurred()) SWIG_fail;
39687 }
39688 {
39689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39690 }
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39698 PyObject *resultobj = 0;
39699 wxMenu *arg1 = (wxMenu *) 0 ;
39700 size_t result;
39701 void *argp1 = 0 ;
39702 int res1 = 0 ;
39703 PyObject *swig_obj[1] ;
39704
39705 if (!args) SWIG_fail;
39706 swig_obj[0] = args;
39707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39708 if (!SWIG_IsOK(res1)) {
39709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39710 }
39711 arg1 = reinterpret_cast< wxMenu * >(argp1);
39712 {
39713 PyThreadState* __tstate = wxPyBeginAllowThreads();
39714 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39715 wxPyEndAllowThreads(__tstate);
39716 if (PyErr_Occurred()) SWIG_fail;
39717 }
39718 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39719 return resultobj;
39720 fail:
39721 return NULL;
39722 }
39723
39724
39725 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39726 PyObject *resultobj = 0;
39727 wxMenu *arg1 = (wxMenu *) 0 ;
39728 PyObject *result = 0 ;
39729 void *argp1 = 0 ;
39730 int res1 = 0 ;
39731 PyObject *swig_obj[1] ;
39732
39733 if (!args) SWIG_fail;
39734 swig_obj[0] = args;
39735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39736 if (!SWIG_IsOK(res1)) {
39737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39738 }
39739 arg1 = reinterpret_cast< wxMenu * >(argp1);
39740 {
39741 PyThreadState* __tstate = wxPyBeginAllowThreads();
39742 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39743 wxPyEndAllowThreads(__tstate);
39744 if (PyErr_Occurred()) SWIG_fail;
39745 }
39746 resultobj = result;
39747 return resultobj;
39748 fail:
39749 return NULL;
39750 }
39751
39752
39753 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39754 PyObject *resultobj = 0;
39755 wxMenu *arg1 = (wxMenu *) 0 ;
39756 wxString *arg2 = 0 ;
39757 int result;
39758 void *argp1 = 0 ;
39759 int res1 = 0 ;
39760 bool temp2 = false ;
39761 PyObject * obj0 = 0 ;
39762 PyObject * obj1 = 0 ;
39763 char * kwnames[] = {
39764 (char *) "self",(char *) "item", NULL
39765 };
39766
39767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39769 if (!SWIG_IsOK(res1)) {
39770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39771 }
39772 arg1 = reinterpret_cast< wxMenu * >(argp1);
39773 {
39774 arg2 = wxString_in_helper(obj1);
39775 if (arg2 == NULL) SWIG_fail;
39776 temp2 = true;
39777 }
39778 {
39779 PyThreadState* __tstate = wxPyBeginAllowThreads();
39780 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 resultobj = SWIG_From_int(static_cast< int >(result));
39785 {
39786 if (temp2)
39787 delete arg2;
39788 }
39789 return resultobj;
39790 fail:
39791 {
39792 if (temp2)
39793 delete arg2;
39794 }
39795 return NULL;
39796 }
39797
39798
39799 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39800 PyObject *resultobj = 0;
39801 wxMenu *arg1 = (wxMenu *) 0 ;
39802 int arg2 ;
39803 wxMenuItem *result = 0 ;
39804 void *argp1 = 0 ;
39805 int res1 = 0 ;
39806 int val2 ;
39807 int ecode2 = 0 ;
39808 PyObject * obj0 = 0 ;
39809 PyObject * obj1 = 0 ;
39810 char * kwnames[] = {
39811 (char *) "self",(char *) "id", NULL
39812 };
39813
39814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39816 if (!SWIG_IsOK(res1)) {
39817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39818 }
39819 arg1 = reinterpret_cast< wxMenu * >(argp1);
39820 ecode2 = SWIG_AsVal_int(obj1, &val2);
39821 if (!SWIG_IsOK(ecode2)) {
39822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39823 }
39824 arg2 = static_cast< int >(val2);
39825 {
39826 PyThreadState* __tstate = wxPyBeginAllowThreads();
39827 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39828 wxPyEndAllowThreads(__tstate);
39829 if (PyErr_Occurred()) SWIG_fail;
39830 }
39831 {
39832 resultobj = wxPyMake_wxObject(result, (bool)0);
39833 }
39834 return resultobj;
39835 fail:
39836 return NULL;
39837 }
39838
39839
39840 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39841 PyObject *resultobj = 0;
39842 wxMenu *arg1 = (wxMenu *) 0 ;
39843 size_t arg2 ;
39844 wxMenuItem *result = 0 ;
39845 void *argp1 = 0 ;
39846 int res1 = 0 ;
39847 size_t val2 ;
39848 int ecode2 = 0 ;
39849 PyObject * obj0 = 0 ;
39850 PyObject * obj1 = 0 ;
39851 char * kwnames[] = {
39852 (char *) "self",(char *) "position", NULL
39853 };
39854
39855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39857 if (!SWIG_IsOK(res1)) {
39858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39859 }
39860 arg1 = reinterpret_cast< wxMenu * >(argp1);
39861 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39862 if (!SWIG_IsOK(ecode2)) {
39863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39864 }
39865 arg2 = static_cast< size_t >(val2);
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 resultobj = wxPyMake_wxObject(result, (bool)0);
39874 }
39875 return resultobj;
39876 fail:
39877 return NULL;
39878 }
39879
39880
39881 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39882 PyObject *resultobj = 0;
39883 wxMenu *arg1 = (wxMenu *) 0 ;
39884 int arg2 ;
39885 bool arg3 ;
39886 void *argp1 = 0 ;
39887 int res1 = 0 ;
39888 int val2 ;
39889 int ecode2 = 0 ;
39890 bool val3 ;
39891 int ecode3 = 0 ;
39892 PyObject * obj0 = 0 ;
39893 PyObject * obj1 = 0 ;
39894 PyObject * obj2 = 0 ;
39895 char * kwnames[] = {
39896 (char *) "self",(char *) "id",(char *) "enable", NULL
39897 };
39898
39899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39901 if (!SWIG_IsOK(res1)) {
39902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39903 }
39904 arg1 = reinterpret_cast< wxMenu * >(argp1);
39905 ecode2 = SWIG_AsVal_int(obj1, &val2);
39906 if (!SWIG_IsOK(ecode2)) {
39907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39908 }
39909 arg2 = static_cast< int >(val2);
39910 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39911 if (!SWIG_IsOK(ecode3)) {
39912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39913 }
39914 arg3 = static_cast< bool >(val3);
39915 {
39916 PyThreadState* __tstate = wxPyBeginAllowThreads();
39917 (arg1)->Enable(arg2,arg3);
39918 wxPyEndAllowThreads(__tstate);
39919 if (PyErr_Occurred()) SWIG_fail;
39920 }
39921 resultobj = SWIG_Py_Void();
39922 return resultobj;
39923 fail:
39924 return NULL;
39925 }
39926
39927
39928 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39929 PyObject *resultobj = 0;
39930 wxMenu *arg1 = (wxMenu *) 0 ;
39931 int arg2 ;
39932 bool result;
39933 void *argp1 = 0 ;
39934 int res1 = 0 ;
39935 int val2 ;
39936 int ecode2 = 0 ;
39937 PyObject * obj0 = 0 ;
39938 PyObject * obj1 = 0 ;
39939 char * kwnames[] = {
39940 (char *) "self",(char *) "id", NULL
39941 };
39942
39943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39945 if (!SWIG_IsOK(res1)) {
39946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39947 }
39948 arg1 = reinterpret_cast< wxMenu * >(argp1);
39949 ecode2 = SWIG_AsVal_int(obj1, &val2);
39950 if (!SWIG_IsOK(ecode2)) {
39951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39952 }
39953 arg2 = static_cast< int >(val2);
39954 {
39955 PyThreadState* __tstate = wxPyBeginAllowThreads();
39956 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39957 wxPyEndAllowThreads(__tstate);
39958 if (PyErr_Occurred()) SWIG_fail;
39959 }
39960 {
39961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39962 }
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39970 PyObject *resultobj = 0;
39971 wxMenu *arg1 = (wxMenu *) 0 ;
39972 int arg2 ;
39973 bool arg3 ;
39974 void *argp1 = 0 ;
39975 int res1 = 0 ;
39976 int val2 ;
39977 int ecode2 = 0 ;
39978 bool val3 ;
39979 int ecode3 = 0 ;
39980 PyObject * obj0 = 0 ;
39981 PyObject * obj1 = 0 ;
39982 PyObject * obj2 = 0 ;
39983 char * kwnames[] = {
39984 (char *) "self",(char *) "id",(char *) "check", NULL
39985 };
39986
39987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39989 if (!SWIG_IsOK(res1)) {
39990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39991 }
39992 arg1 = reinterpret_cast< wxMenu * >(argp1);
39993 ecode2 = SWIG_AsVal_int(obj1, &val2);
39994 if (!SWIG_IsOK(ecode2)) {
39995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39996 }
39997 arg2 = static_cast< int >(val2);
39998 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39999 if (!SWIG_IsOK(ecode3)) {
40000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40001 }
40002 arg3 = static_cast< bool >(val3);
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 (arg1)->Check(arg2,arg3);
40006 wxPyEndAllowThreads(__tstate);
40007 if (PyErr_Occurred()) SWIG_fail;
40008 }
40009 resultobj = SWIG_Py_Void();
40010 return resultobj;
40011 fail:
40012 return NULL;
40013 }
40014
40015
40016 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40017 PyObject *resultobj = 0;
40018 wxMenu *arg1 = (wxMenu *) 0 ;
40019 int arg2 ;
40020 bool result;
40021 void *argp1 = 0 ;
40022 int res1 = 0 ;
40023 int val2 ;
40024 int ecode2 = 0 ;
40025 PyObject * obj0 = 0 ;
40026 PyObject * obj1 = 0 ;
40027 char * kwnames[] = {
40028 (char *) "self",(char *) "id", NULL
40029 };
40030
40031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40033 if (!SWIG_IsOK(res1)) {
40034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40035 }
40036 arg1 = reinterpret_cast< wxMenu * >(argp1);
40037 ecode2 = SWIG_AsVal_int(obj1, &val2);
40038 if (!SWIG_IsOK(ecode2)) {
40039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40040 }
40041 arg2 = static_cast< int >(val2);
40042 {
40043 PyThreadState* __tstate = wxPyBeginAllowThreads();
40044 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40045 wxPyEndAllowThreads(__tstate);
40046 if (PyErr_Occurred()) SWIG_fail;
40047 }
40048 {
40049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40050 }
40051 return resultobj;
40052 fail:
40053 return NULL;
40054 }
40055
40056
40057 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40058 PyObject *resultobj = 0;
40059 wxMenu *arg1 = (wxMenu *) 0 ;
40060 int arg2 ;
40061 wxString *arg3 = 0 ;
40062 void *argp1 = 0 ;
40063 int res1 = 0 ;
40064 int val2 ;
40065 int ecode2 = 0 ;
40066 bool temp3 = false ;
40067 PyObject * obj0 = 0 ;
40068 PyObject * obj1 = 0 ;
40069 PyObject * obj2 = 0 ;
40070 char * kwnames[] = {
40071 (char *) "self",(char *) "id",(char *) "label", NULL
40072 };
40073
40074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40076 if (!SWIG_IsOK(res1)) {
40077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40078 }
40079 arg1 = reinterpret_cast< wxMenu * >(argp1);
40080 ecode2 = SWIG_AsVal_int(obj1, &val2);
40081 if (!SWIG_IsOK(ecode2)) {
40082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40083 }
40084 arg2 = static_cast< int >(val2);
40085 {
40086 arg3 = wxString_in_helper(obj2);
40087 if (arg3 == NULL) SWIG_fail;
40088 temp3 = true;
40089 }
40090 {
40091 PyThreadState* __tstate = wxPyBeginAllowThreads();
40092 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40093 wxPyEndAllowThreads(__tstate);
40094 if (PyErr_Occurred()) SWIG_fail;
40095 }
40096 resultobj = SWIG_Py_Void();
40097 {
40098 if (temp3)
40099 delete arg3;
40100 }
40101 return resultobj;
40102 fail:
40103 {
40104 if (temp3)
40105 delete arg3;
40106 }
40107 return NULL;
40108 }
40109
40110
40111 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40112 PyObject *resultobj = 0;
40113 wxMenu *arg1 = (wxMenu *) 0 ;
40114 int arg2 ;
40115 wxString result;
40116 void *argp1 = 0 ;
40117 int res1 = 0 ;
40118 int val2 ;
40119 int ecode2 = 0 ;
40120 PyObject * obj0 = 0 ;
40121 PyObject * obj1 = 0 ;
40122 char * kwnames[] = {
40123 (char *) "self",(char *) "id", NULL
40124 };
40125
40126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40130 }
40131 arg1 = reinterpret_cast< wxMenu * >(argp1);
40132 ecode2 = SWIG_AsVal_int(obj1, &val2);
40133 if (!SWIG_IsOK(ecode2)) {
40134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40135 }
40136 arg2 = static_cast< int >(val2);
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 {
40144 #if wxUSE_UNICODE
40145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40146 #else
40147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40148 #endif
40149 }
40150 return resultobj;
40151 fail:
40152 return NULL;
40153 }
40154
40155
40156 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40157 PyObject *resultobj = 0;
40158 wxMenu *arg1 = (wxMenu *) 0 ;
40159 int arg2 ;
40160 wxString *arg3 = 0 ;
40161 void *argp1 = 0 ;
40162 int res1 = 0 ;
40163 int val2 ;
40164 int ecode2 = 0 ;
40165 bool temp3 = false ;
40166 PyObject * obj0 = 0 ;
40167 PyObject * obj1 = 0 ;
40168 PyObject * obj2 = 0 ;
40169 char * kwnames[] = {
40170 (char *) "self",(char *) "id",(char *) "helpString", NULL
40171 };
40172
40173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40175 if (!SWIG_IsOK(res1)) {
40176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40177 }
40178 arg1 = reinterpret_cast< wxMenu * >(argp1);
40179 ecode2 = SWIG_AsVal_int(obj1, &val2);
40180 if (!SWIG_IsOK(ecode2)) {
40181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40182 }
40183 arg2 = static_cast< int >(val2);
40184 {
40185 arg3 = wxString_in_helper(obj2);
40186 if (arg3 == NULL) SWIG_fail;
40187 temp3 = true;
40188 }
40189 {
40190 PyThreadState* __tstate = wxPyBeginAllowThreads();
40191 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40192 wxPyEndAllowThreads(__tstate);
40193 if (PyErr_Occurred()) SWIG_fail;
40194 }
40195 resultobj = SWIG_Py_Void();
40196 {
40197 if (temp3)
40198 delete arg3;
40199 }
40200 return resultobj;
40201 fail:
40202 {
40203 if (temp3)
40204 delete arg3;
40205 }
40206 return NULL;
40207 }
40208
40209
40210 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40211 PyObject *resultobj = 0;
40212 wxMenu *arg1 = (wxMenu *) 0 ;
40213 int arg2 ;
40214 wxString result;
40215 void *argp1 = 0 ;
40216 int res1 = 0 ;
40217 int val2 ;
40218 int ecode2 = 0 ;
40219 PyObject * obj0 = 0 ;
40220 PyObject * obj1 = 0 ;
40221 char * kwnames[] = {
40222 (char *) "self",(char *) "id", NULL
40223 };
40224
40225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40227 if (!SWIG_IsOK(res1)) {
40228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40229 }
40230 arg1 = reinterpret_cast< wxMenu * >(argp1);
40231 ecode2 = SWIG_AsVal_int(obj1, &val2);
40232 if (!SWIG_IsOK(ecode2)) {
40233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40234 }
40235 arg2 = static_cast< int >(val2);
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40239 wxPyEndAllowThreads(__tstate);
40240 if (PyErr_Occurred()) SWIG_fail;
40241 }
40242 {
40243 #if wxUSE_UNICODE
40244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40245 #else
40246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40247 #endif
40248 }
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj = 0;
40257 wxMenu *arg1 = (wxMenu *) 0 ;
40258 wxString *arg2 = 0 ;
40259 void *argp1 = 0 ;
40260 int res1 = 0 ;
40261 bool temp2 = false ;
40262 PyObject * obj0 = 0 ;
40263 PyObject * obj1 = 0 ;
40264 char * kwnames[] = {
40265 (char *) "self",(char *) "title", NULL
40266 };
40267
40268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40270 if (!SWIG_IsOK(res1)) {
40271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40272 }
40273 arg1 = reinterpret_cast< wxMenu * >(argp1);
40274 {
40275 arg2 = wxString_in_helper(obj1);
40276 if (arg2 == NULL) SWIG_fail;
40277 temp2 = true;
40278 }
40279 {
40280 PyThreadState* __tstate = wxPyBeginAllowThreads();
40281 (arg1)->SetTitle((wxString const &)*arg2);
40282 wxPyEndAllowThreads(__tstate);
40283 if (PyErr_Occurred()) SWIG_fail;
40284 }
40285 resultobj = SWIG_Py_Void();
40286 {
40287 if (temp2)
40288 delete arg2;
40289 }
40290 return resultobj;
40291 fail:
40292 {
40293 if (temp2)
40294 delete arg2;
40295 }
40296 return NULL;
40297 }
40298
40299
40300 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40301 PyObject *resultobj = 0;
40302 wxMenu *arg1 = (wxMenu *) 0 ;
40303 wxString result;
40304 void *argp1 = 0 ;
40305 int res1 = 0 ;
40306 PyObject *swig_obj[1] ;
40307
40308 if (!args) SWIG_fail;
40309 swig_obj[0] = args;
40310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40311 if (!SWIG_IsOK(res1)) {
40312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40313 }
40314 arg1 = reinterpret_cast< wxMenu * >(argp1);
40315 {
40316 PyThreadState* __tstate = wxPyBeginAllowThreads();
40317 result = ((wxMenu const *)arg1)->GetTitle();
40318 wxPyEndAllowThreads(__tstate);
40319 if (PyErr_Occurred()) SWIG_fail;
40320 }
40321 {
40322 #if wxUSE_UNICODE
40323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40324 #else
40325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40326 #endif
40327 }
40328 return resultobj;
40329 fail:
40330 return NULL;
40331 }
40332
40333
40334 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40335 PyObject *resultobj = 0;
40336 wxMenu *arg1 = (wxMenu *) 0 ;
40337 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40338 void *argp1 = 0 ;
40339 int res1 = 0 ;
40340 void *argp2 = 0 ;
40341 int res2 = 0 ;
40342 PyObject * obj0 = 0 ;
40343 PyObject * obj1 = 0 ;
40344 char * kwnames[] = {
40345 (char *) "self",(char *) "handler", NULL
40346 };
40347
40348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40350 if (!SWIG_IsOK(res1)) {
40351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40352 }
40353 arg1 = reinterpret_cast< wxMenu * >(argp1);
40354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40355 if (!SWIG_IsOK(res2)) {
40356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40357 }
40358 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 (arg1)->SetEventHandler(arg2);
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_Py_Void();
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40373 PyObject *resultobj = 0;
40374 wxMenu *arg1 = (wxMenu *) 0 ;
40375 wxEvtHandler *result = 0 ;
40376 void *argp1 = 0 ;
40377 int res1 = 0 ;
40378 PyObject *swig_obj[1] ;
40379
40380 if (!args) SWIG_fail;
40381 swig_obj[0] = args;
40382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40383 if (!SWIG_IsOK(res1)) {
40384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40385 }
40386 arg1 = reinterpret_cast< wxMenu * >(argp1);
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40390 wxPyEndAllowThreads(__tstate);
40391 if (PyErr_Occurred()) SWIG_fail;
40392 }
40393 {
40394 resultobj = wxPyMake_wxObject(result, 0);
40395 }
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40403 PyObject *resultobj = 0;
40404 wxMenu *arg1 = (wxMenu *) 0 ;
40405 wxWindow *arg2 = (wxWindow *) 0 ;
40406 void *argp1 = 0 ;
40407 int res1 = 0 ;
40408 void *argp2 = 0 ;
40409 int res2 = 0 ;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 char * kwnames[] = {
40413 (char *) "self",(char *) "win", NULL
40414 };
40415
40416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40418 if (!SWIG_IsOK(res1)) {
40419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40420 }
40421 arg1 = reinterpret_cast< wxMenu * >(argp1);
40422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40423 if (!SWIG_IsOK(res2)) {
40424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40425 }
40426 arg2 = reinterpret_cast< wxWindow * >(argp2);
40427 {
40428 PyThreadState* __tstate = wxPyBeginAllowThreads();
40429 (arg1)->SetInvokingWindow(arg2);
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 resultobj = SWIG_Py_Void();
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40441 PyObject *resultobj = 0;
40442 wxMenu *arg1 = (wxMenu *) 0 ;
40443 wxWindow *result = 0 ;
40444 void *argp1 = 0 ;
40445 int res1 = 0 ;
40446 PyObject *swig_obj[1] ;
40447
40448 if (!args) SWIG_fail;
40449 swig_obj[0] = args;
40450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40451 if (!SWIG_IsOK(res1)) {
40452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40453 }
40454 arg1 = reinterpret_cast< wxMenu * >(argp1);
40455 {
40456 PyThreadState* __tstate = wxPyBeginAllowThreads();
40457 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40458 wxPyEndAllowThreads(__tstate);
40459 if (PyErr_Occurred()) SWIG_fail;
40460 }
40461 {
40462 resultobj = wxPyMake_wxObject(result, 0);
40463 }
40464 return resultobj;
40465 fail:
40466 return NULL;
40467 }
40468
40469
40470 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40471 PyObject *resultobj = 0;
40472 wxMenu *arg1 = (wxMenu *) 0 ;
40473 long result;
40474 void *argp1 = 0 ;
40475 int res1 = 0 ;
40476 PyObject *swig_obj[1] ;
40477
40478 if (!args) SWIG_fail;
40479 swig_obj[0] = args;
40480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40481 if (!SWIG_IsOK(res1)) {
40482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40483 }
40484 arg1 = reinterpret_cast< wxMenu * >(argp1);
40485 {
40486 PyThreadState* __tstate = wxPyBeginAllowThreads();
40487 result = (long)((wxMenu const *)arg1)->GetStyle();
40488 wxPyEndAllowThreads(__tstate);
40489 if (PyErr_Occurred()) SWIG_fail;
40490 }
40491 resultobj = SWIG_From_long(static_cast< long >(result));
40492 return resultobj;
40493 fail:
40494 return NULL;
40495 }
40496
40497
40498 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40499 PyObject *resultobj = 0;
40500 wxMenu *arg1 = (wxMenu *) 0 ;
40501 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40502 void *argp1 = 0 ;
40503 int res1 = 0 ;
40504 void *argp2 = 0 ;
40505 int res2 = 0 ;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 char * kwnames[] = {
40509 (char *) "self",(char *) "source", NULL
40510 };
40511
40512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40514 if (!SWIG_IsOK(res1)) {
40515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40516 }
40517 arg1 = reinterpret_cast< wxMenu * >(argp1);
40518 if (obj1) {
40519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40520 if (!SWIG_IsOK(res2)) {
40521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40522 }
40523 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40524 }
40525 {
40526 PyThreadState* __tstate = wxPyBeginAllowThreads();
40527 (arg1)->UpdateUI(arg2);
40528 wxPyEndAllowThreads(__tstate);
40529 if (PyErr_Occurred()) SWIG_fail;
40530 }
40531 resultobj = SWIG_Py_Void();
40532 return resultobj;
40533 fail:
40534 return NULL;
40535 }
40536
40537
40538 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40539 PyObject *resultobj = 0;
40540 wxMenu *arg1 = (wxMenu *) 0 ;
40541 wxMenuBar *result = 0 ;
40542 void *argp1 = 0 ;
40543 int res1 = 0 ;
40544 PyObject *swig_obj[1] ;
40545
40546 if (!args) SWIG_fail;
40547 swig_obj[0] = args;
40548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40549 if (!SWIG_IsOK(res1)) {
40550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40551 }
40552 arg1 = reinterpret_cast< wxMenu * >(argp1);
40553 {
40554 PyThreadState* __tstate = wxPyBeginAllowThreads();
40555 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40556 wxPyEndAllowThreads(__tstate);
40557 if (PyErr_Occurred()) SWIG_fail;
40558 }
40559 {
40560 resultobj = wxPyMake_wxObject(result, (bool)0);
40561 }
40562 return resultobj;
40563 fail:
40564 return NULL;
40565 }
40566
40567
40568 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40569 PyObject *resultobj = 0;
40570 wxMenu *arg1 = (wxMenu *) 0 ;
40571 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40572 void *argp1 = 0 ;
40573 int res1 = 0 ;
40574 void *argp2 = 0 ;
40575 int res2 = 0 ;
40576 PyObject * obj0 = 0 ;
40577 PyObject * obj1 = 0 ;
40578 char * kwnames[] = {
40579 (char *) "self",(char *) "menubar", NULL
40580 };
40581
40582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40584 if (!SWIG_IsOK(res1)) {
40585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40586 }
40587 arg1 = reinterpret_cast< wxMenu * >(argp1);
40588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40589 if (!SWIG_IsOK(res2)) {
40590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40591 }
40592 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40593 {
40594 PyThreadState* __tstate = wxPyBeginAllowThreads();
40595 (arg1)->Attach(arg2);
40596 wxPyEndAllowThreads(__tstate);
40597 if (PyErr_Occurred()) SWIG_fail;
40598 }
40599 resultobj = SWIG_Py_Void();
40600 return resultobj;
40601 fail:
40602 return NULL;
40603 }
40604
40605
40606 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40607 PyObject *resultobj = 0;
40608 wxMenu *arg1 = (wxMenu *) 0 ;
40609 void *argp1 = 0 ;
40610 int res1 = 0 ;
40611 PyObject *swig_obj[1] ;
40612
40613 if (!args) SWIG_fail;
40614 swig_obj[0] = args;
40615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40616 if (!SWIG_IsOK(res1)) {
40617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40618 }
40619 arg1 = reinterpret_cast< wxMenu * >(argp1);
40620 {
40621 PyThreadState* __tstate = wxPyBeginAllowThreads();
40622 (arg1)->Detach();
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_Py_Void();
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40634 PyObject *resultobj = 0;
40635 wxMenu *arg1 = (wxMenu *) 0 ;
40636 bool result;
40637 void *argp1 = 0 ;
40638 int res1 = 0 ;
40639 PyObject *swig_obj[1] ;
40640
40641 if (!args) SWIG_fail;
40642 swig_obj[0] = args;
40643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40644 if (!SWIG_IsOK(res1)) {
40645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40646 }
40647 arg1 = reinterpret_cast< wxMenu * >(argp1);
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 result = (bool)((wxMenu const *)arg1)->IsAttached();
40651 wxPyEndAllowThreads(__tstate);
40652 if (PyErr_Occurred()) SWIG_fail;
40653 }
40654 {
40655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40656 }
40657 return resultobj;
40658 fail:
40659 return NULL;
40660 }
40661
40662
40663 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40664 PyObject *resultobj = 0;
40665 wxMenu *arg1 = (wxMenu *) 0 ;
40666 wxMenu *arg2 = (wxMenu *) 0 ;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 void *argp2 = 0 ;
40670 int res2 = 0 ;
40671 PyObject * obj0 = 0 ;
40672 PyObject * obj1 = 0 ;
40673 char * kwnames[] = {
40674 (char *) "self",(char *) "parent", NULL
40675 };
40676
40677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40679 if (!SWIG_IsOK(res1)) {
40680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40681 }
40682 arg1 = reinterpret_cast< wxMenu * >(argp1);
40683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40684 if (!SWIG_IsOK(res2)) {
40685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40686 }
40687 arg2 = reinterpret_cast< wxMenu * >(argp2);
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 (arg1)->SetParent(arg2);
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 resultobj = SWIG_Py_Void();
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40702 PyObject *resultobj = 0;
40703 wxMenu *arg1 = (wxMenu *) 0 ;
40704 wxMenu *result = 0 ;
40705 void *argp1 = 0 ;
40706 int res1 = 0 ;
40707 PyObject *swig_obj[1] ;
40708
40709 if (!args) SWIG_fail;
40710 swig_obj[0] = args;
40711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40712 if (!SWIG_IsOK(res1)) {
40713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40714 }
40715 arg1 = reinterpret_cast< wxMenu * >(argp1);
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40719 wxPyEndAllowThreads(__tstate);
40720 if (PyErr_Occurred()) SWIG_fail;
40721 }
40722 {
40723 resultobj = wxPyMake_wxObject(result, 0);
40724 }
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40732 PyObject *obj;
40733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40734 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40735 return SWIG_Py_Void();
40736 }
40737
40738 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40739 return SWIG_Python_InitShadowInstance(args);
40740 }
40741
40742 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40743 PyObject *resultobj = 0;
40744 long arg1 = (long) 0 ;
40745 wxMenuBar *result = 0 ;
40746 long val1 ;
40747 int ecode1 = 0 ;
40748 PyObject * obj0 = 0 ;
40749 char * kwnames[] = {
40750 (char *) "style", NULL
40751 };
40752
40753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40754 if (obj0) {
40755 ecode1 = SWIG_AsVal_long(obj0, &val1);
40756 if (!SWIG_IsOK(ecode1)) {
40757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40758 }
40759 arg1 = static_cast< long >(val1);
40760 }
40761 {
40762 if (!wxPyCheckForApp()) SWIG_fail;
40763 PyThreadState* __tstate = wxPyBeginAllowThreads();
40764 result = (wxMenuBar *)new wxMenuBar(arg1);
40765 wxPyEndAllowThreads(__tstate);
40766 if (PyErr_Occurred()) SWIG_fail;
40767 }
40768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40769 return resultobj;
40770 fail:
40771 return NULL;
40772 }
40773
40774
40775 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40776 PyObject *resultobj = 0;
40777 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40778 wxMenu *arg2 = (wxMenu *) 0 ;
40779 wxString *arg3 = 0 ;
40780 bool result;
40781 void *argp1 = 0 ;
40782 int res1 = 0 ;
40783 void *argp2 = 0 ;
40784 int res2 = 0 ;
40785 bool temp3 = false ;
40786 PyObject * obj0 = 0 ;
40787 PyObject * obj1 = 0 ;
40788 PyObject * obj2 = 0 ;
40789 char * kwnames[] = {
40790 (char *) "self",(char *) "menu",(char *) "title", NULL
40791 };
40792
40793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40795 if (!SWIG_IsOK(res1)) {
40796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40797 }
40798 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40800 if (!SWIG_IsOK(res2)) {
40801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40802 }
40803 arg2 = reinterpret_cast< wxMenu * >(argp2);
40804 {
40805 arg3 = wxString_in_helper(obj2);
40806 if (arg3 == NULL) SWIG_fail;
40807 temp3 = true;
40808 }
40809 {
40810 PyThreadState* __tstate = wxPyBeginAllowThreads();
40811 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40812 wxPyEndAllowThreads(__tstate);
40813 if (PyErr_Occurred()) SWIG_fail;
40814 }
40815 {
40816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40817 }
40818 {
40819 if (temp3)
40820 delete arg3;
40821 }
40822 return resultobj;
40823 fail:
40824 {
40825 if (temp3)
40826 delete arg3;
40827 }
40828 return NULL;
40829 }
40830
40831
40832 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40833 PyObject *resultobj = 0;
40834 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40835 size_t arg2 ;
40836 wxMenu *arg3 = (wxMenu *) 0 ;
40837 wxString *arg4 = 0 ;
40838 bool result;
40839 void *argp1 = 0 ;
40840 int res1 = 0 ;
40841 size_t val2 ;
40842 int ecode2 = 0 ;
40843 void *argp3 = 0 ;
40844 int res3 = 0 ;
40845 bool temp4 = false ;
40846 PyObject * obj0 = 0 ;
40847 PyObject * obj1 = 0 ;
40848 PyObject * obj2 = 0 ;
40849 PyObject * obj3 = 0 ;
40850 char * kwnames[] = {
40851 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40852 };
40853
40854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40856 if (!SWIG_IsOK(res1)) {
40857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40858 }
40859 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40860 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40861 if (!SWIG_IsOK(ecode2)) {
40862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40863 }
40864 arg2 = static_cast< size_t >(val2);
40865 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40866 if (!SWIG_IsOK(res3)) {
40867 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40868 }
40869 arg3 = reinterpret_cast< wxMenu * >(argp3);
40870 {
40871 arg4 = wxString_in_helper(obj3);
40872 if (arg4 == NULL) SWIG_fail;
40873 temp4 = true;
40874 }
40875 {
40876 PyThreadState* __tstate = wxPyBeginAllowThreads();
40877 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40878 wxPyEndAllowThreads(__tstate);
40879 if (PyErr_Occurred()) SWIG_fail;
40880 }
40881 {
40882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40883 }
40884 {
40885 if (temp4)
40886 delete arg4;
40887 }
40888 return resultobj;
40889 fail:
40890 {
40891 if (temp4)
40892 delete arg4;
40893 }
40894 return NULL;
40895 }
40896
40897
40898 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40899 PyObject *resultobj = 0;
40900 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40901 size_t result;
40902 void *argp1 = 0 ;
40903 int res1 = 0 ;
40904 PyObject *swig_obj[1] ;
40905
40906 if (!args) SWIG_fail;
40907 swig_obj[0] = args;
40908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40909 if (!SWIG_IsOK(res1)) {
40910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40911 }
40912 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40913 {
40914 PyThreadState* __tstate = wxPyBeginAllowThreads();
40915 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40916 wxPyEndAllowThreads(__tstate);
40917 if (PyErr_Occurred()) SWIG_fail;
40918 }
40919 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40920 return resultobj;
40921 fail:
40922 return NULL;
40923 }
40924
40925
40926 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40927 PyObject *resultobj = 0;
40928 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40929 size_t arg2 ;
40930 wxMenu *result = 0 ;
40931 void *argp1 = 0 ;
40932 int res1 = 0 ;
40933 size_t val2 ;
40934 int ecode2 = 0 ;
40935 PyObject * obj0 = 0 ;
40936 PyObject * obj1 = 0 ;
40937 char * kwnames[] = {
40938 (char *) "self",(char *) "pos", NULL
40939 };
40940
40941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40943 if (!SWIG_IsOK(res1)) {
40944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40945 }
40946 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40947 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40948 if (!SWIG_IsOK(ecode2)) {
40949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40950 }
40951 arg2 = static_cast< size_t >(val2);
40952 {
40953 PyThreadState* __tstate = wxPyBeginAllowThreads();
40954 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40955 wxPyEndAllowThreads(__tstate);
40956 if (PyErr_Occurred()) SWIG_fail;
40957 }
40958 {
40959 resultobj = wxPyMake_wxObject(result, 0);
40960 }
40961 return resultobj;
40962 fail:
40963 return NULL;
40964 }
40965
40966
40967 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40968 PyObject *resultobj = 0;
40969 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40970 size_t arg2 ;
40971 wxMenu *arg3 = (wxMenu *) 0 ;
40972 wxString *arg4 = 0 ;
40973 wxMenu *result = 0 ;
40974 void *argp1 = 0 ;
40975 int res1 = 0 ;
40976 size_t val2 ;
40977 int ecode2 = 0 ;
40978 void *argp3 = 0 ;
40979 int res3 = 0 ;
40980 bool temp4 = false ;
40981 PyObject * obj0 = 0 ;
40982 PyObject * obj1 = 0 ;
40983 PyObject * obj2 = 0 ;
40984 PyObject * obj3 = 0 ;
40985 char * kwnames[] = {
40986 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40987 };
40988
40989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40991 if (!SWIG_IsOK(res1)) {
40992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40993 }
40994 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40995 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40996 if (!SWIG_IsOK(ecode2)) {
40997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40998 }
40999 arg2 = static_cast< size_t >(val2);
41000 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41001 if (!SWIG_IsOK(res3)) {
41002 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41003 }
41004 arg3 = reinterpret_cast< wxMenu * >(argp3);
41005 {
41006 arg4 = wxString_in_helper(obj3);
41007 if (arg4 == NULL) SWIG_fail;
41008 temp4 = true;
41009 }
41010 {
41011 PyThreadState* __tstate = wxPyBeginAllowThreads();
41012 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41013 wxPyEndAllowThreads(__tstate);
41014 if (PyErr_Occurred()) SWIG_fail;
41015 }
41016 {
41017 resultobj = wxPyMake_wxObject(result, 0);
41018 }
41019 {
41020 if (temp4)
41021 delete arg4;
41022 }
41023 return resultobj;
41024 fail:
41025 {
41026 if (temp4)
41027 delete arg4;
41028 }
41029 return NULL;
41030 }
41031
41032
41033 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41034 PyObject *resultobj = 0;
41035 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41036 size_t arg2 ;
41037 wxMenu *result = 0 ;
41038 void *argp1 = 0 ;
41039 int res1 = 0 ;
41040 size_t val2 ;
41041 int ecode2 = 0 ;
41042 PyObject * obj0 = 0 ;
41043 PyObject * obj1 = 0 ;
41044 char * kwnames[] = {
41045 (char *) "self",(char *) "pos", NULL
41046 };
41047
41048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41050 if (!SWIG_IsOK(res1)) {
41051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41052 }
41053 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41054 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41055 if (!SWIG_IsOK(ecode2)) {
41056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41057 }
41058 arg2 = static_cast< size_t >(val2);
41059 {
41060 PyThreadState* __tstate = wxPyBeginAllowThreads();
41061 result = (wxMenu *)(arg1)->Remove(arg2);
41062 wxPyEndAllowThreads(__tstate);
41063 if (PyErr_Occurred()) SWIG_fail;
41064 }
41065 {
41066 resultobj = wxPyMake_wxObject(result, 0);
41067 }
41068 return resultobj;
41069 fail:
41070 return NULL;
41071 }
41072
41073
41074 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41075 PyObject *resultobj = 0;
41076 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41077 size_t arg2 ;
41078 bool arg3 ;
41079 void *argp1 = 0 ;
41080 int res1 = 0 ;
41081 size_t val2 ;
41082 int ecode2 = 0 ;
41083 bool val3 ;
41084 int ecode3 = 0 ;
41085 PyObject * obj0 = 0 ;
41086 PyObject * obj1 = 0 ;
41087 PyObject * obj2 = 0 ;
41088 char * kwnames[] = {
41089 (char *) "self",(char *) "pos",(char *) "enable", NULL
41090 };
41091
41092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41094 if (!SWIG_IsOK(res1)) {
41095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41096 }
41097 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41098 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41099 if (!SWIG_IsOK(ecode2)) {
41100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41101 }
41102 arg2 = static_cast< size_t >(val2);
41103 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41104 if (!SWIG_IsOK(ecode3)) {
41105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41106 }
41107 arg3 = static_cast< bool >(val3);
41108 {
41109 PyThreadState* __tstate = wxPyBeginAllowThreads();
41110 (arg1)->EnableTop(arg2,arg3);
41111 wxPyEndAllowThreads(__tstate);
41112 if (PyErr_Occurred()) SWIG_fail;
41113 }
41114 resultobj = SWIG_Py_Void();
41115 return resultobj;
41116 fail:
41117 return NULL;
41118 }
41119
41120
41121 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41122 PyObject *resultobj = 0;
41123 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41124 size_t arg2 ;
41125 bool result;
41126 void *argp1 = 0 ;
41127 int res1 = 0 ;
41128 size_t val2 ;
41129 int ecode2 = 0 ;
41130 PyObject * obj0 = 0 ;
41131 PyObject * obj1 = 0 ;
41132 char * kwnames[] = {
41133 (char *) "self",(char *) "pos", NULL
41134 };
41135
41136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41138 if (!SWIG_IsOK(res1)) {
41139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41140 }
41141 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41142 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41143 if (!SWIG_IsOK(ecode2)) {
41144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41145 }
41146 arg2 = static_cast< size_t >(val2);
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 {
41154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41155 }
41156 return resultobj;
41157 fail:
41158 return NULL;
41159 }
41160
41161
41162 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41163 PyObject *resultobj = 0;
41164 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41165 size_t arg2 ;
41166 wxString *arg3 = 0 ;
41167 void *argp1 = 0 ;
41168 int res1 = 0 ;
41169 size_t val2 ;
41170 int ecode2 = 0 ;
41171 bool temp3 = false ;
41172 PyObject * obj0 = 0 ;
41173 PyObject * obj1 = 0 ;
41174 PyObject * obj2 = 0 ;
41175 char * kwnames[] = {
41176 (char *) "self",(char *) "pos",(char *) "label", NULL
41177 };
41178
41179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41181 if (!SWIG_IsOK(res1)) {
41182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41183 }
41184 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41185 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41186 if (!SWIG_IsOK(ecode2)) {
41187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41188 }
41189 arg2 = static_cast< size_t >(val2);
41190 {
41191 arg3 = wxString_in_helper(obj2);
41192 if (arg3 == NULL) SWIG_fail;
41193 temp3 = true;
41194 }
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 resultobj = SWIG_Py_Void();
41202 {
41203 if (temp3)
41204 delete arg3;
41205 }
41206 return resultobj;
41207 fail:
41208 {
41209 if (temp3)
41210 delete arg3;
41211 }
41212 return NULL;
41213 }
41214
41215
41216 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41217 PyObject *resultobj = 0;
41218 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41219 size_t arg2 ;
41220 wxString result;
41221 void *argp1 = 0 ;
41222 int res1 = 0 ;
41223 size_t val2 ;
41224 int ecode2 = 0 ;
41225 PyObject * obj0 = 0 ;
41226 PyObject * obj1 = 0 ;
41227 char * kwnames[] = {
41228 (char *) "self",(char *) "pos", NULL
41229 };
41230
41231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41233 if (!SWIG_IsOK(res1)) {
41234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41235 }
41236 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41237 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41238 if (!SWIG_IsOK(ecode2)) {
41239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41240 }
41241 arg2 = static_cast< size_t >(val2);
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 {
41249 #if wxUSE_UNICODE
41250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41251 #else
41252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41253 #endif
41254 }
41255 return resultobj;
41256 fail:
41257 return NULL;
41258 }
41259
41260
41261 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41262 PyObject *resultobj = 0;
41263 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41264 wxString *arg2 = 0 ;
41265 wxString *arg3 = 0 ;
41266 int result;
41267 void *argp1 = 0 ;
41268 int res1 = 0 ;
41269 bool temp2 = false ;
41270 bool temp3 = false ;
41271 PyObject * obj0 = 0 ;
41272 PyObject * obj1 = 0 ;
41273 PyObject * obj2 = 0 ;
41274 char * kwnames[] = {
41275 (char *) "self",(char *) "menu",(char *) "item", NULL
41276 };
41277
41278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41280 if (!SWIG_IsOK(res1)) {
41281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41282 }
41283 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41284 {
41285 arg2 = wxString_in_helper(obj1);
41286 if (arg2 == NULL) SWIG_fail;
41287 temp2 = true;
41288 }
41289 {
41290 arg3 = wxString_in_helper(obj2);
41291 if (arg3 == NULL) SWIG_fail;
41292 temp3 = true;
41293 }
41294 {
41295 PyThreadState* __tstate = wxPyBeginAllowThreads();
41296 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41297 wxPyEndAllowThreads(__tstate);
41298 if (PyErr_Occurred()) SWIG_fail;
41299 }
41300 resultobj = SWIG_From_int(static_cast< int >(result));
41301 {
41302 if (temp2)
41303 delete arg2;
41304 }
41305 {
41306 if (temp3)
41307 delete arg3;
41308 }
41309 return resultobj;
41310 fail:
41311 {
41312 if (temp2)
41313 delete arg2;
41314 }
41315 {
41316 if (temp3)
41317 delete arg3;
41318 }
41319 return NULL;
41320 }
41321
41322
41323 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41324 PyObject *resultobj = 0;
41325 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41326 int arg2 ;
41327 wxMenuItem *result = 0 ;
41328 void *argp1 = 0 ;
41329 int res1 = 0 ;
41330 int val2 ;
41331 int ecode2 = 0 ;
41332 PyObject * obj0 = 0 ;
41333 PyObject * obj1 = 0 ;
41334 char * kwnames[] = {
41335 (char *) "self",(char *) "id", NULL
41336 };
41337
41338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41340 if (!SWIG_IsOK(res1)) {
41341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41342 }
41343 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41344 ecode2 = SWIG_AsVal_int(obj1, &val2);
41345 if (!SWIG_IsOK(ecode2)) {
41346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41347 }
41348 arg2 = static_cast< int >(val2);
41349 {
41350 PyThreadState* __tstate = wxPyBeginAllowThreads();
41351 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41352 wxPyEndAllowThreads(__tstate);
41353 if (PyErr_Occurred()) SWIG_fail;
41354 }
41355 {
41356 resultobj = wxPyMake_wxObject(result, (bool)0);
41357 }
41358 return resultobj;
41359 fail:
41360 return NULL;
41361 }
41362
41363
41364 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41365 PyObject *resultobj = 0;
41366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41367 wxString *arg2 = 0 ;
41368 int result;
41369 void *argp1 = 0 ;
41370 int res1 = 0 ;
41371 bool temp2 = false ;
41372 PyObject * obj0 = 0 ;
41373 PyObject * obj1 = 0 ;
41374 char * kwnames[] = {
41375 (char *) "self",(char *) "title", NULL
41376 };
41377
41378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41380 if (!SWIG_IsOK(res1)) {
41381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41382 }
41383 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41384 {
41385 arg2 = wxString_in_helper(obj1);
41386 if (arg2 == NULL) SWIG_fail;
41387 temp2 = true;
41388 }
41389 {
41390 PyThreadState* __tstate = wxPyBeginAllowThreads();
41391 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 resultobj = SWIG_From_int(static_cast< int >(result));
41396 {
41397 if (temp2)
41398 delete arg2;
41399 }
41400 return resultobj;
41401 fail:
41402 {
41403 if (temp2)
41404 delete arg2;
41405 }
41406 return NULL;
41407 }
41408
41409
41410 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41411 PyObject *resultobj = 0;
41412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41413 int arg2 ;
41414 bool arg3 ;
41415 void *argp1 = 0 ;
41416 int res1 = 0 ;
41417 int val2 ;
41418 int ecode2 = 0 ;
41419 bool val3 ;
41420 int ecode3 = 0 ;
41421 PyObject * obj0 = 0 ;
41422 PyObject * obj1 = 0 ;
41423 PyObject * obj2 = 0 ;
41424 char * kwnames[] = {
41425 (char *) "self",(char *) "id",(char *) "enable", NULL
41426 };
41427
41428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41430 if (!SWIG_IsOK(res1)) {
41431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41432 }
41433 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41434 ecode2 = SWIG_AsVal_int(obj1, &val2);
41435 if (!SWIG_IsOK(ecode2)) {
41436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41437 }
41438 arg2 = static_cast< int >(val2);
41439 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41440 if (!SWIG_IsOK(ecode3)) {
41441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41442 }
41443 arg3 = static_cast< bool >(val3);
41444 {
41445 PyThreadState* __tstate = wxPyBeginAllowThreads();
41446 (arg1)->Enable(arg2,arg3);
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 resultobj = SWIG_Py_Void();
41451 return resultobj;
41452 fail:
41453 return NULL;
41454 }
41455
41456
41457 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41458 PyObject *resultobj = 0;
41459 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41460 int arg2 ;
41461 bool arg3 ;
41462 void *argp1 = 0 ;
41463 int res1 = 0 ;
41464 int val2 ;
41465 int ecode2 = 0 ;
41466 bool val3 ;
41467 int ecode3 = 0 ;
41468 PyObject * obj0 = 0 ;
41469 PyObject * obj1 = 0 ;
41470 PyObject * obj2 = 0 ;
41471 char * kwnames[] = {
41472 (char *) "self",(char *) "id",(char *) "check", NULL
41473 };
41474
41475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41477 if (!SWIG_IsOK(res1)) {
41478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41479 }
41480 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41481 ecode2 = SWIG_AsVal_int(obj1, &val2);
41482 if (!SWIG_IsOK(ecode2)) {
41483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41484 }
41485 arg2 = static_cast< int >(val2);
41486 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41487 if (!SWIG_IsOK(ecode3)) {
41488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41489 }
41490 arg3 = static_cast< bool >(val3);
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 (arg1)->Check(arg2,arg3);
41494 wxPyEndAllowThreads(__tstate);
41495 if (PyErr_Occurred()) SWIG_fail;
41496 }
41497 resultobj = SWIG_Py_Void();
41498 return resultobj;
41499 fail:
41500 return NULL;
41501 }
41502
41503
41504 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41505 PyObject *resultobj = 0;
41506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41507 int arg2 ;
41508 bool result;
41509 void *argp1 = 0 ;
41510 int res1 = 0 ;
41511 int val2 ;
41512 int ecode2 = 0 ;
41513 PyObject * obj0 = 0 ;
41514 PyObject * obj1 = 0 ;
41515 char * kwnames[] = {
41516 (char *) "self",(char *) "id", NULL
41517 };
41518
41519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41521 if (!SWIG_IsOK(res1)) {
41522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41523 }
41524 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41525 ecode2 = SWIG_AsVal_int(obj1, &val2);
41526 if (!SWIG_IsOK(ecode2)) {
41527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41528 }
41529 arg2 = static_cast< int >(val2);
41530 {
41531 PyThreadState* __tstate = wxPyBeginAllowThreads();
41532 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41533 wxPyEndAllowThreads(__tstate);
41534 if (PyErr_Occurred()) SWIG_fail;
41535 }
41536 {
41537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41538 }
41539 return resultobj;
41540 fail:
41541 return NULL;
41542 }
41543
41544
41545 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41546 PyObject *resultobj = 0;
41547 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41548 int arg2 ;
41549 bool result;
41550 void *argp1 = 0 ;
41551 int res1 = 0 ;
41552 int val2 ;
41553 int ecode2 = 0 ;
41554 PyObject * obj0 = 0 ;
41555 PyObject * obj1 = 0 ;
41556 char * kwnames[] = {
41557 (char *) "self",(char *) "id", NULL
41558 };
41559
41560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41562 if (!SWIG_IsOK(res1)) {
41563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41564 }
41565 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41566 ecode2 = SWIG_AsVal_int(obj1, &val2);
41567 if (!SWIG_IsOK(ecode2)) {
41568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41569 }
41570 arg2 = static_cast< int >(val2);
41571 {
41572 PyThreadState* __tstate = wxPyBeginAllowThreads();
41573 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41574 wxPyEndAllowThreads(__tstate);
41575 if (PyErr_Occurred()) SWIG_fail;
41576 }
41577 {
41578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41579 }
41580 return resultobj;
41581 fail:
41582 return NULL;
41583 }
41584
41585
41586 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41587 PyObject *resultobj = 0;
41588 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41589 int arg2 ;
41590 wxString *arg3 = 0 ;
41591 void *argp1 = 0 ;
41592 int res1 = 0 ;
41593 int val2 ;
41594 int ecode2 = 0 ;
41595 bool temp3 = false ;
41596 PyObject * obj0 = 0 ;
41597 PyObject * obj1 = 0 ;
41598 PyObject * obj2 = 0 ;
41599 char * kwnames[] = {
41600 (char *) "self",(char *) "id",(char *) "label", NULL
41601 };
41602
41603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41605 if (!SWIG_IsOK(res1)) {
41606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41607 }
41608 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41609 ecode2 = SWIG_AsVal_int(obj1, &val2);
41610 if (!SWIG_IsOK(ecode2)) {
41611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41612 }
41613 arg2 = static_cast< int >(val2);
41614 {
41615 arg3 = wxString_in_helper(obj2);
41616 if (arg3 == NULL) SWIG_fail;
41617 temp3 = true;
41618 }
41619 {
41620 PyThreadState* __tstate = wxPyBeginAllowThreads();
41621 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41622 wxPyEndAllowThreads(__tstate);
41623 if (PyErr_Occurred()) SWIG_fail;
41624 }
41625 resultobj = SWIG_Py_Void();
41626 {
41627 if (temp3)
41628 delete arg3;
41629 }
41630 return resultobj;
41631 fail:
41632 {
41633 if (temp3)
41634 delete arg3;
41635 }
41636 return NULL;
41637 }
41638
41639
41640 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41641 PyObject *resultobj = 0;
41642 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41643 int arg2 ;
41644 wxString result;
41645 void *argp1 = 0 ;
41646 int res1 = 0 ;
41647 int val2 ;
41648 int ecode2 = 0 ;
41649 PyObject * obj0 = 0 ;
41650 PyObject * obj1 = 0 ;
41651 char * kwnames[] = {
41652 (char *) "self",(char *) "id", NULL
41653 };
41654
41655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41657 if (!SWIG_IsOK(res1)) {
41658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41659 }
41660 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41661 ecode2 = SWIG_AsVal_int(obj1, &val2);
41662 if (!SWIG_IsOK(ecode2)) {
41663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41664 }
41665 arg2 = static_cast< int >(val2);
41666 {
41667 PyThreadState* __tstate = wxPyBeginAllowThreads();
41668 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41669 wxPyEndAllowThreads(__tstate);
41670 if (PyErr_Occurred()) SWIG_fail;
41671 }
41672 {
41673 #if wxUSE_UNICODE
41674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41675 #else
41676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41677 #endif
41678 }
41679 return resultobj;
41680 fail:
41681 return NULL;
41682 }
41683
41684
41685 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41686 PyObject *resultobj = 0;
41687 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41688 int arg2 ;
41689 wxString *arg3 = 0 ;
41690 void *argp1 = 0 ;
41691 int res1 = 0 ;
41692 int val2 ;
41693 int ecode2 = 0 ;
41694 bool temp3 = false ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 char * kwnames[] = {
41699 (char *) "self",(char *) "id",(char *) "helpString", NULL
41700 };
41701
41702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41704 if (!SWIG_IsOK(res1)) {
41705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41706 }
41707 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41708 ecode2 = SWIG_AsVal_int(obj1, &val2);
41709 if (!SWIG_IsOK(ecode2)) {
41710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41711 }
41712 arg2 = static_cast< int >(val2);
41713 {
41714 arg3 = wxString_in_helper(obj2);
41715 if (arg3 == NULL) SWIG_fail;
41716 temp3 = true;
41717 }
41718 {
41719 PyThreadState* __tstate = wxPyBeginAllowThreads();
41720 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41721 wxPyEndAllowThreads(__tstate);
41722 if (PyErr_Occurred()) SWIG_fail;
41723 }
41724 resultobj = SWIG_Py_Void();
41725 {
41726 if (temp3)
41727 delete arg3;
41728 }
41729 return resultobj;
41730 fail:
41731 {
41732 if (temp3)
41733 delete arg3;
41734 }
41735 return NULL;
41736 }
41737
41738
41739 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41740 PyObject *resultobj = 0;
41741 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41742 int arg2 ;
41743 wxString result;
41744 void *argp1 = 0 ;
41745 int res1 = 0 ;
41746 int val2 ;
41747 int ecode2 = 0 ;
41748 PyObject * obj0 = 0 ;
41749 PyObject * obj1 = 0 ;
41750 char * kwnames[] = {
41751 (char *) "self",(char *) "id", NULL
41752 };
41753
41754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41756 if (!SWIG_IsOK(res1)) {
41757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41758 }
41759 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41760 ecode2 = SWIG_AsVal_int(obj1, &val2);
41761 if (!SWIG_IsOK(ecode2)) {
41762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41763 }
41764 arg2 = static_cast< int >(val2);
41765 {
41766 PyThreadState* __tstate = wxPyBeginAllowThreads();
41767 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41768 wxPyEndAllowThreads(__tstate);
41769 if (PyErr_Occurred()) SWIG_fail;
41770 }
41771 {
41772 #if wxUSE_UNICODE
41773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41774 #else
41775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41776 #endif
41777 }
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41785 PyObject *resultobj = 0;
41786 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41787 wxFrame *result = 0 ;
41788 void *argp1 = 0 ;
41789 int res1 = 0 ;
41790 PyObject *swig_obj[1] ;
41791
41792 if (!args) SWIG_fail;
41793 swig_obj[0] = args;
41794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41795 if (!SWIG_IsOK(res1)) {
41796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41797 }
41798 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41799 {
41800 PyThreadState* __tstate = wxPyBeginAllowThreads();
41801 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41802 wxPyEndAllowThreads(__tstate);
41803 if (PyErr_Occurred()) SWIG_fail;
41804 }
41805 {
41806 resultobj = wxPyMake_wxObject(result, (bool)0);
41807 }
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41815 PyObject *resultobj = 0;
41816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41817 bool result;
41818 void *argp1 = 0 ;
41819 int res1 = 0 ;
41820 PyObject *swig_obj[1] ;
41821
41822 if (!args) SWIG_fail;
41823 swig_obj[0] = args;
41824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41825 if (!SWIG_IsOK(res1)) {
41826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41827 }
41828 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41829 {
41830 PyThreadState* __tstate = wxPyBeginAllowThreads();
41831 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41832 wxPyEndAllowThreads(__tstate);
41833 if (PyErr_Occurred()) SWIG_fail;
41834 }
41835 {
41836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41837 }
41838 return resultobj;
41839 fail:
41840 return NULL;
41841 }
41842
41843
41844 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41845 PyObject *resultobj = 0;
41846 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41847 wxFrame *arg2 = (wxFrame *) 0 ;
41848 void *argp1 = 0 ;
41849 int res1 = 0 ;
41850 void *argp2 = 0 ;
41851 int res2 = 0 ;
41852 PyObject * obj0 = 0 ;
41853 PyObject * obj1 = 0 ;
41854 char * kwnames[] = {
41855 (char *) "self",(char *) "frame", NULL
41856 };
41857
41858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41860 if (!SWIG_IsOK(res1)) {
41861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41862 }
41863 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41865 if (!SWIG_IsOK(res2)) {
41866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41867 }
41868 arg2 = reinterpret_cast< wxFrame * >(argp2);
41869 {
41870 PyThreadState* __tstate = wxPyBeginAllowThreads();
41871 (arg1)->Attach(arg2);
41872 wxPyEndAllowThreads(__tstate);
41873 if (PyErr_Occurred()) SWIG_fail;
41874 }
41875 resultobj = SWIG_Py_Void();
41876 return resultobj;
41877 fail:
41878 return NULL;
41879 }
41880
41881
41882 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41883 PyObject *resultobj = 0;
41884 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41885 void *argp1 = 0 ;
41886 int res1 = 0 ;
41887 PyObject *swig_obj[1] ;
41888
41889 if (!args) SWIG_fail;
41890 swig_obj[0] = args;
41891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 (arg1)->Detach();
41899 wxPyEndAllowThreads(__tstate);
41900 if (PyErr_Occurred()) SWIG_fail;
41901 }
41902 resultobj = SWIG_Py_Void();
41903 return resultobj;
41904 fail:
41905 return NULL;
41906 }
41907
41908
41909 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41910 PyObject *resultobj = 0;
41911 bool arg1 ;
41912 bool val1 ;
41913 int ecode1 = 0 ;
41914 PyObject * obj0 = 0 ;
41915 char * kwnames[] = {
41916 (char *) "enable", NULL
41917 };
41918
41919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41920 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41921 if (!SWIG_IsOK(ecode1)) {
41922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41923 }
41924 arg1 = static_cast< bool >(val1);
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 wxMenuBar_SetAutoWindowMenu(arg1);
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 resultobj = SWIG_Py_Void();
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41939 PyObject *resultobj = 0;
41940 bool result;
41941
41942 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41943 {
41944 PyThreadState* __tstate = wxPyBeginAllowThreads();
41945 result = (bool)wxMenuBar_GetAutoWindowMenu();
41946 wxPyEndAllowThreads(__tstate);
41947 if (PyErr_Occurred()) SWIG_fail;
41948 }
41949 {
41950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41951 }
41952 return resultobj;
41953 fail:
41954 return NULL;
41955 }
41956
41957
41958 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41959 PyObject *obj;
41960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41961 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41962 return SWIG_Py_Void();
41963 }
41964
41965 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41966 return SWIG_Python_InitShadowInstance(args);
41967 }
41968
41969 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41970 PyObject *resultobj = 0;
41971 wxMenu *arg1 = (wxMenu *) NULL ;
41972 int arg2 = (int) wxID_ANY ;
41973 wxString const &arg3_defvalue = wxPyEmptyString ;
41974 wxString *arg3 = (wxString *) &arg3_defvalue ;
41975 wxString const &arg4_defvalue = wxPyEmptyString ;
41976 wxString *arg4 = (wxString *) &arg4_defvalue ;
41977 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41978 wxMenu *arg6 = (wxMenu *) NULL ;
41979 wxMenuItem *result = 0 ;
41980 void *argp1 = 0 ;
41981 int res1 = 0 ;
41982 int val2 ;
41983 int ecode2 = 0 ;
41984 bool temp3 = false ;
41985 bool temp4 = false ;
41986 int val5 ;
41987 int ecode5 = 0 ;
41988 void *argp6 = 0 ;
41989 int res6 = 0 ;
41990 PyObject * obj0 = 0 ;
41991 PyObject * obj1 = 0 ;
41992 PyObject * obj2 = 0 ;
41993 PyObject * obj3 = 0 ;
41994 PyObject * obj4 = 0 ;
41995 PyObject * obj5 = 0 ;
41996 char * kwnames[] = {
41997 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41998 };
41999
42000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42001 if (obj0) {
42002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42003 if (!SWIG_IsOK(res1)) {
42004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42005 }
42006 arg1 = reinterpret_cast< wxMenu * >(argp1);
42007 }
42008 if (obj1) {
42009 ecode2 = SWIG_AsVal_int(obj1, &val2);
42010 if (!SWIG_IsOK(ecode2)) {
42011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42012 }
42013 arg2 = static_cast< int >(val2);
42014 }
42015 if (obj2) {
42016 {
42017 arg3 = wxString_in_helper(obj2);
42018 if (arg3 == NULL) SWIG_fail;
42019 temp3 = true;
42020 }
42021 }
42022 if (obj3) {
42023 {
42024 arg4 = wxString_in_helper(obj3);
42025 if (arg4 == NULL) SWIG_fail;
42026 temp4 = true;
42027 }
42028 }
42029 if (obj4) {
42030 ecode5 = SWIG_AsVal_int(obj4, &val5);
42031 if (!SWIG_IsOK(ecode5)) {
42032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42033 }
42034 arg5 = static_cast< wxItemKind >(val5);
42035 }
42036 if (obj5) {
42037 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42038 if (!SWIG_IsOK(res6)) {
42039 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42040 }
42041 arg6 = reinterpret_cast< wxMenu * >(argp6);
42042 }
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42046 wxPyEndAllowThreads(__tstate);
42047 if (PyErr_Occurred()) SWIG_fail;
42048 }
42049 {
42050 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42051 }
42052 {
42053 if (temp3)
42054 delete arg3;
42055 }
42056 {
42057 if (temp4)
42058 delete arg4;
42059 }
42060 return resultobj;
42061 fail:
42062 {
42063 if (temp3)
42064 delete arg3;
42065 }
42066 {
42067 if (temp4)
42068 delete arg4;
42069 }
42070 return NULL;
42071 }
42072
42073
42074 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42075 PyObject *resultobj = 0;
42076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42077 void *argp1 = 0 ;
42078 int res1 = 0 ;
42079 PyObject *swig_obj[1] ;
42080
42081 if (!args) SWIG_fail;
42082 swig_obj[0] = args;
42083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42084 if (!SWIG_IsOK(res1)) {
42085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42086 }
42087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42088 {
42089 PyThreadState* __tstate = wxPyBeginAllowThreads();
42090 delete arg1;
42091
42092 wxPyEndAllowThreads(__tstate);
42093 if (PyErr_Occurred()) SWIG_fail;
42094 }
42095 resultobj = SWIG_Py_Void();
42096 return resultobj;
42097 fail:
42098 return NULL;
42099 }
42100
42101
42102 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42103 PyObject *resultobj = 0;
42104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42105 wxMenu *result = 0 ;
42106 void *argp1 = 0 ;
42107 int res1 = 0 ;
42108 PyObject *swig_obj[1] ;
42109
42110 if (!args) SWIG_fail;
42111 swig_obj[0] = args;
42112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42113 if (!SWIG_IsOK(res1)) {
42114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42115 }
42116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42117 {
42118 PyThreadState* __tstate = wxPyBeginAllowThreads();
42119 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42120 wxPyEndAllowThreads(__tstate);
42121 if (PyErr_Occurred()) SWIG_fail;
42122 }
42123 {
42124 resultobj = wxPyMake_wxObject(result, 0);
42125 }
42126 return resultobj;
42127 fail:
42128 return NULL;
42129 }
42130
42131
42132 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42133 PyObject *resultobj = 0;
42134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42135 wxMenu *arg2 = (wxMenu *) 0 ;
42136 void *argp1 = 0 ;
42137 int res1 = 0 ;
42138 void *argp2 = 0 ;
42139 int res2 = 0 ;
42140 PyObject * obj0 = 0 ;
42141 PyObject * obj1 = 0 ;
42142 char * kwnames[] = {
42143 (char *) "self",(char *) "menu", NULL
42144 };
42145
42146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42148 if (!SWIG_IsOK(res1)) {
42149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42150 }
42151 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42153 if (!SWIG_IsOK(res2)) {
42154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42155 }
42156 arg2 = reinterpret_cast< wxMenu * >(argp2);
42157 {
42158 PyThreadState* __tstate = wxPyBeginAllowThreads();
42159 (arg1)->SetMenu(arg2);
42160 wxPyEndAllowThreads(__tstate);
42161 if (PyErr_Occurred()) SWIG_fail;
42162 }
42163 resultobj = SWIG_Py_Void();
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj = 0;
42172 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42173 int arg2 ;
42174 void *argp1 = 0 ;
42175 int res1 = 0 ;
42176 int val2 ;
42177 int ecode2 = 0 ;
42178 PyObject * obj0 = 0 ;
42179 PyObject * obj1 = 0 ;
42180 char * kwnames[] = {
42181 (char *) "self",(char *) "id", NULL
42182 };
42183
42184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42186 if (!SWIG_IsOK(res1)) {
42187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42188 }
42189 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42190 ecode2 = SWIG_AsVal_int(obj1, &val2);
42191 if (!SWIG_IsOK(ecode2)) {
42192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42193 }
42194 arg2 = static_cast< int >(val2);
42195 {
42196 PyThreadState* __tstate = wxPyBeginAllowThreads();
42197 (arg1)->SetId(arg2);
42198 wxPyEndAllowThreads(__tstate);
42199 if (PyErr_Occurred()) SWIG_fail;
42200 }
42201 resultobj = SWIG_Py_Void();
42202 return resultobj;
42203 fail:
42204 return NULL;
42205 }
42206
42207
42208 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42209 PyObject *resultobj = 0;
42210 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42211 int result;
42212 void *argp1 = 0 ;
42213 int res1 = 0 ;
42214 PyObject *swig_obj[1] ;
42215
42216 if (!args) SWIG_fail;
42217 swig_obj[0] = args;
42218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42219 if (!SWIG_IsOK(res1)) {
42220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42221 }
42222 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 result = (int)((wxMenuItem const *)arg1)->GetId();
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 resultobj = SWIG_From_int(static_cast< int >(result));
42230 return resultobj;
42231 fail:
42232 return NULL;
42233 }
42234
42235
42236 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42237 PyObject *resultobj = 0;
42238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42239 bool result;
42240 void *argp1 = 0 ;
42241 int res1 = 0 ;
42242 PyObject *swig_obj[1] ;
42243
42244 if (!args) SWIG_fail;
42245 swig_obj[0] = args;
42246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42247 if (!SWIG_IsOK(res1)) {
42248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42249 }
42250 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42251 {
42252 PyThreadState* __tstate = wxPyBeginAllowThreads();
42253 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42254 wxPyEndAllowThreads(__tstate);
42255 if (PyErr_Occurred()) SWIG_fail;
42256 }
42257 {
42258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42259 }
42260 return resultobj;
42261 fail:
42262 return NULL;
42263 }
42264
42265
42266 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42267 PyObject *resultobj = 0;
42268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42269 wxString *arg2 = 0 ;
42270 void *argp1 = 0 ;
42271 int res1 = 0 ;
42272 bool temp2 = false ;
42273 PyObject * obj0 = 0 ;
42274 PyObject * obj1 = 0 ;
42275 char * kwnames[] = {
42276 (char *) "self",(char *) "str", NULL
42277 };
42278
42279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42281 if (!SWIG_IsOK(res1)) {
42282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42283 }
42284 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42285 {
42286 arg2 = wxString_in_helper(obj1);
42287 if (arg2 == NULL) SWIG_fail;
42288 temp2 = true;
42289 }
42290 {
42291 PyThreadState* __tstate = wxPyBeginAllowThreads();
42292 (arg1)->SetText((wxString const &)*arg2);
42293 wxPyEndAllowThreads(__tstate);
42294 if (PyErr_Occurred()) SWIG_fail;
42295 }
42296 resultobj = SWIG_Py_Void();
42297 {
42298 if (temp2)
42299 delete arg2;
42300 }
42301 return resultobj;
42302 fail:
42303 {
42304 if (temp2)
42305 delete arg2;
42306 }
42307 return NULL;
42308 }
42309
42310
42311 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42312 PyObject *resultobj = 0;
42313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42314 wxString result;
42315 void *argp1 = 0 ;
42316 int res1 = 0 ;
42317 PyObject *swig_obj[1] ;
42318
42319 if (!args) SWIG_fail;
42320 swig_obj[0] = args;
42321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42322 if (!SWIG_IsOK(res1)) {
42323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42324 }
42325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 result = ((wxMenuItem const *)arg1)->GetLabel();
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 {
42333 #if wxUSE_UNICODE
42334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42335 #else
42336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42337 #endif
42338 }
42339 return resultobj;
42340 fail:
42341 return NULL;
42342 }
42343
42344
42345 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42346 PyObject *resultobj = 0;
42347 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42348 wxString *result = 0 ;
42349 void *argp1 = 0 ;
42350 int res1 = 0 ;
42351 PyObject *swig_obj[1] ;
42352
42353 if (!args) SWIG_fail;
42354 swig_obj[0] = args;
42355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42356 if (!SWIG_IsOK(res1)) {
42357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42358 }
42359 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42360 {
42361 PyThreadState* __tstate = wxPyBeginAllowThreads();
42362 {
42363 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42364 result = (wxString *) &_result_ref;
42365 }
42366 wxPyEndAllowThreads(__tstate);
42367 if (PyErr_Occurred()) SWIG_fail;
42368 }
42369 {
42370 #if wxUSE_UNICODE
42371 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42372 #else
42373 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42374 #endif
42375 }
42376 return resultobj;
42377 fail:
42378 return NULL;
42379 }
42380
42381
42382 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42383 PyObject *resultobj = 0;
42384 wxString *arg1 = 0 ;
42385 wxString result;
42386 bool temp1 = false ;
42387 PyObject * obj0 = 0 ;
42388 char * kwnames[] = {
42389 (char *) "text", NULL
42390 };
42391
42392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42393 {
42394 arg1 = wxString_in_helper(obj0);
42395 if (arg1 == NULL) SWIG_fail;
42396 temp1 = true;
42397 }
42398 {
42399 PyThreadState* __tstate = wxPyBeginAllowThreads();
42400 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42401 wxPyEndAllowThreads(__tstate);
42402 if (PyErr_Occurred()) SWIG_fail;
42403 }
42404 {
42405 #if wxUSE_UNICODE
42406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42407 #else
42408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42409 #endif
42410 }
42411 {
42412 if (temp1)
42413 delete arg1;
42414 }
42415 return resultobj;
42416 fail:
42417 {
42418 if (temp1)
42419 delete arg1;
42420 }
42421 return NULL;
42422 }
42423
42424
42425 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42426 PyObject *resultobj = 0;
42427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42428 wxItemKind result;
42429 void *argp1 = 0 ;
42430 int res1 = 0 ;
42431 PyObject *swig_obj[1] ;
42432
42433 if (!args) SWIG_fail;
42434 swig_obj[0] = args;
42435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42436 if (!SWIG_IsOK(res1)) {
42437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42438 }
42439 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42440 {
42441 PyThreadState* __tstate = wxPyBeginAllowThreads();
42442 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42443 wxPyEndAllowThreads(__tstate);
42444 if (PyErr_Occurred()) SWIG_fail;
42445 }
42446 resultobj = SWIG_From_int(static_cast< int >(result));
42447 return resultobj;
42448 fail:
42449 return NULL;
42450 }
42451
42452
42453 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj = 0;
42455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42456 wxItemKind arg2 ;
42457 void *argp1 = 0 ;
42458 int res1 = 0 ;
42459 int val2 ;
42460 int ecode2 = 0 ;
42461 PyObject * obj0 = 0 ;
42462 PyObject * obj1 = 0 ;
42463 char * kwnames[] = {
42464 (char *) "self",(char *) "kind", NULL
42465 };
42466
42467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42469 if (!SWIG_IsOK(res1)) {
42470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42471 }
42472 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42473 ecode2 = SWIG_AsVal_int(obj1, &val2);
42474 if (!SWIG_IsOK(ecode2)) {
42475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42476 }
42477 arg2 = static_cast< wxItemKind >(val2);
42478 {
42479 PyThreadState* __tstate = wxPyBeginAllowThreads();
42480 (arg1)->SetKind(arg2);
42481 wxPyEndAllowThreads(__tstate);
42482 if (PyErr_Occurred()) SWIG_fail;
42483 }
42484 resultobj = SWIG_Py_Void();
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj = 0;
42493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42494 bool arg2 ;
42495 void *argp1 = 0 ;
42496 int res1 = 0 ;
42497 bool val2 ;
42498 int ecode2 = 0 ;
42499 PyObject * obj0 = 0 ;
42500 PyObject * obj1 = 0 ;
42501 char * kwnames[] = {
42502 (char *) "self",(char *) "checkable", NULL
42503 };
42504
42505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42507 if (!SWIG_IsOK(res1)) {
42508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42509 }
42510 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42511 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42512 if (!SWIG_IsOK(ecode2)) {
42513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42514 }
42515 arg2 = static_cast< bool >(val2);
42516 {
42517 PyThreadState* __tstate = wxPyBeginAllowThreads();
42518 (arg1)->SetCheckable(arg2);
42519 wxPyEndAllowThreads(__tstate);
42520 if (PyErr_Occurred()) SWIG_fail;
42521 }
42522 resultobj = SWIG_Py_Void();
42523 return resultobj;
42524 fail:
42525 return NULL;
42526 }
42527
42528
42529 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42530 PyObject *resultobj = 0;
42531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42532 bool result;
42533 void *argp1 = 0 ;
42534 int res1 = 0 ;
42535 PyObject *swig_obj[1] ;
42536
42537 if (!args) SWIG_fail;
42538 swig_obj[0] = args;
42539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42540 if (!SWIG_IsOK(res1)) {
42541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42542 }
42543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42547 wxPyEndAllowThreads(__tstate);
42548 if (PyErr_Occurred()) SWIG_fail;
42549 }
42550 {
42551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42552 }
42553 return resultobj;
42554 fail:
42555 return NULL;
42556 }
42557
42558
42559 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42560 PyObject *resultobj = 0;
42561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42562 bool result;
42563 void *argp1 = 0 ;
42564 int res1 = 0 ;
42565 PyObject *swig_obj[1] ;
42566
42567 if (!args) SWIG_fail;
42568 swig_obj[0] = args;
42569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42570 if (!SWIG_IsOK(res1)) {
42571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42572 }
42573 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42574 {
42575 PyThreadState* __tstate = wxPyBeginAllowThreads();
42576 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42577 wxPyEndAllowThreads(__tstate);
42578 if (PyErr_Occurred()) SWIG_fail;
42579 }
42580 {
42581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42582 }
42583 return resultobj;
42584 fail:
42585 return NULL;
42586 }
42587
42588
42589 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42590 PyObject *resultobj = 0;
42591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42592 wxMenu *arg2 = (wxMenu *) 0 ;
42593 void *argp1 = 0 ;
42594 int res1 = 0 ;
42595 void *argp2 = 0 ;
42596 int res2 = 0 ;
42597 PyObject * obj0 = 0 ;
42598 PyObject * obj1 = 0 ;
42599 char * kwnames[] = {
42600 (char *) "self",(char *) "menu", NULL
42601 };
42602
42603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42605 if (!SWIG_IsOK(res1)) {
42606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42607 }
42608 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42610 if (!SWIG_IsOK(res2)) {
42611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42612 }
42613 arg2 = reinterpret_cast< wxMenu * >(argp2);
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 (arg1)->SetSubMenu(arg2);
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 resultobj = SWIG_Py_Void();
42621 return resultobj;
42622 fail:
42623 return NULL;
42624 }
42625
42626
42627 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42628 PyObject *resultobj = 0;
42629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42630 wxMenu *result = 0 ;
42631 void *argp1 = 0 ;
42632 int res1 = 0 ;
42633 PyObject *swig_obj[1] ;
42634
42635 if (!args) SWIG_fail;
42636 swig_obj[0] = args;
42637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42638 if (!SWIG_IsOK(res1)) {
42639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42640 }
42641 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42642 {
42643 PyThreadState* __tstate = wxPyBeginAllowThreads();
42644 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42645 wxPyEndAllowThreads(__tstate);
42646 if (PyErr_Occurred()) SWIG_fail;
42647 }
42648 {
42649 resultobj = wxPyMake_wxObject(result, 0);
42650 }
42651 return resultobj;
42652 fail:
42653 return NULL;
42654 }
42655
42656
42657 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42658 PyObject *resultobj = 0;
42659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42660 bool arg2 = (bool) true ;
42661 void *argp1 = 0 ;
42662 int res1 = 0 ;
42663 bool val2 ;
42664 int ecode2 = 0 ;
42665 PyObject * obj0 = 0 ;
42666 PyObject * obj1 = 0 ;
42667 char * kwnames[] = {
42668 (char *) "self",(char *) "enable", NULL
42669 };
42670
42671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42673 if (!SWIG_IsOK(res1)) {
42674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42675 }
42676 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42677 if (obj1) {
42678 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42679 if (!SWIG_IsOK(ecode2)) {
42680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42681 }
42682 arg2 = static_cast< bool >(val2);
42683 }
42684 {
42685 PyThreadState* __tstate = wxPyBeginAllowThreads();
42686 (arg1)->Enable(arg2);
42687 wxPyEndAllowThreads(__tstate);
42688 if (PyErr_Occurred()) SWIG_fail;
42689 }
42690 resultobj = SWIG_Py_Void();
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42698 PyObject *resultobj = 0;
42699 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42700 bool result;
42701 void *argp1 = 0 ;
42702 int res1 = 0 ;
42703 PyObject *swig_obj[1] ;
42704
42705 if (!args) SWIG_fail;
42706 swig_obj[0] = args;
42707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42708 if (!SWIG_IsOK(res1)) {
42709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42710 }
42711 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42712 {
42713 PyThreadState* __tstate = wxPyBeginAllowThreads();
42714 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 {
42719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42720 }
42721 return resultobj;
42722 fail:
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42728 PyObject *resultobj = 0;
42729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42730 bool arg2 = (bool) true ;
42731 void *argp1 = 0 ;
42732 int res1 = 0 ;
42733 bool val2 ;
42734 int ecode2 = 0 ;
42735 PyObject * obj0 = 0 ;
42736 PyObject * obj1 = 0 ;
42737 char * kwnames[] = {
42738 (char *) "self",(char *) "check", NULL
42739 };
42740
42741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42743 if (!SWIG_IsOK(res1)) {
42744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42745 }
42746 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42747 if (obj1) {
42748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42749 if (!SWIG_IsOK(ecode2)) {
42750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42751 }
42752 arg2 = static_cast< bool >(val2);
42753 }
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 (arg1)->Check(arg2);
42757 wxPyEndAllowThreads(__tstate);
42758 if (PyErr_Occurred()) SWIG_fail;
42759 }
42760 resultobj = SWIG_Py_Void();
42761 return resultobj;
42762 fail:
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42768 PyObject *resultobj = 0;
42769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42770 bool result;
42771 void *argp1 = 0 ;
42772 int res1 = 0 ;
42773 PyObject *swig_obj[1] ;
42774
42775 if (!args) SWIG_fail;
42776 swig_obj[0] = args;
42777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42778 if (!SWIG_IsOK(res1)) {
42779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42780 }
42781 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42782 {
42783 PyThreadState* __tstate = wxPyBeginAllowThreads();
42784 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42785 wxPyEndAllowThreads(__tstate);
42786 if (PyErr_Occurred()) SWIG_fail;
42787 }
42788 {
42789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42790 }
42791 return resultobj;
42792 fail:
42793 return NULL;
42794 }
42795
42796
42797 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42798 PyObject *resultobj = 0;
42799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42800 void *argp1 = 0 ;
42801 int res1 = 0 ;
42802 PyObject *swig_obj[1] ;
42803
42804 if (!args) SWIG_fail;
42805 swig_obj[0] = args;
42806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42807 if (!SWIG_IsOK(res1)) {
42808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42809 }
42810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42811 {
42812 PyThreadState* __tstate = wxPyBeginAllowThreads();
42813 (arg1)->Toggle();
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 resultobj = SWIG_Py_Void();
42818 return resultobj;
42819 fail:
42820 return NULL;
42821 }
42822
42823
42824 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42825 PyObject *resultobj = 0;
42826 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42827 wxString *arg2 = 0 ;
42828 void *argp1 = 0 ;
42829 int res1 = 0 ;
42830 bool temp2 = false ;
42831 PyObject * obj0 = 0 ;
42832 PyObject * obj1 = 0 ;
42833 char * kwnames[] = {
42834 (char *) "self",(char *) "str", NULL
42835 };
42836
42837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42839 if (!SWIG_IsOK(res1)) {
42840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42841 }
42842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42843 {
42844 arg2 = wxString_in_helper(obj1);
42845 if (arg2 == NULL) SWIG_fail;
42846 temp2 = true;
42847 }
42848 {
42849 PyThreadState* __tstate = wxPyBeginAllowThreads();
42850 (arg1)->SetHelp((wxString const &)*arg2);
42851 wxPyEndAllowThreads(__tstate);
42852 if (PyErr_Occurred()) SWIG_fail;
42853 }
42854 resultobj = SWIG_Py_Void();
42855 {
42856 if (temp2)
42857 delete arg2;
42858 }
42859 return resultobj;
42860 fail:
42861 {
42862 if (temp2)
42863 delete arg2;
42864 }
42865 return NULL;
42866 }
42867
42868
42869 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42870 PyObject *resultobj = 0;
42871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42872 wxString *result = 0 ;
42873 void *argp1 = 0 ;
42874 int res1 = 0 ;
42875 PyObject *swig_obj[1] ;
42876
42877 if (!args) SWIG_fail;
42878 swig_obj[0] = args;
42879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42880 if (!SWIG_IsOK(res1)) {
42881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42882 }
42883 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42884 {
42885 PyThreadState* __tstate = wxPyBeginAllowThreads();
42886 {
42887 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42888 result = (wxString *) &_result_ref;
42889 }
42890 wxPyEndAllowThreads(__tstate);
42891 if (PyErr_Occurred()) SWIG_fail;
42892 }
42893 {
42894 #if wxUSE_UNICODE
42895 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42896 #else
42897 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42898 #endif
42899 }
42900 return resultobj;
42901 fail:
42902 return NULL;
42903 }
42904
42905
42906 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42907 PyObject *resultobj = 0;
42908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42909 wxAcceleratorEntry *result = 0 ;
42910 void *argp1 = 0 ;
42911 int res1 = 0 ;
42912 PyObject *swig_obj[1] ;
42913
42914 if (!args) SWIG_fail;
42915 swig_obj[0] = args;
42916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42917 if (!SWIG_IsOK(res1)) {
42918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42919 }
42920 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42921 {
42922 PyThreadState* __tstate = wxPyBeginAllowThreads();
42923 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42924 wxPyEndAllowThreads(__tstate);
42925 if (PyErr_Occurred()) SWIG_fail;
42926 }
42927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42928 return resultobj;
42929 fail:
42930 return NULL;
42931 }
42932
42933
42934 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42935 PyObject *resultobj = 0;
42936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42937 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42938 void *argp1 = 0 ;
42939 int res1 = 0 ;
42940 void *argp2 = 0 ;
42941 int res2 = 0 ;
42942 PyObject * obj0 = 0 ;
42943 PyObject * obj1 = 0 ;
42944 char * kwnames[] = {
42945 (char *) "self",(char *) "accel", NULL
42946 };
42947
42948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42950 if (!SWIG_IsOK(res1)) {
42951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42952 }
42953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42954 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42955 if (!SWIG_IsOK(res2)) {
42956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42957 }
42958 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42959 {
42960 PyThreadState* __tstate = wxPyBeginAllowThreads();
42961 (arg1)->SetAccel(arg2);
42962 wxPyEndAllowThreads(__tstate);
42963 if (PyErr_Occurred()) SWIG_fail;
42964 }
42965 resultobj = SWIG_Py_Void();
42966 return resultobj;
42967 fail:
42968 return NULL;
42969 }
42970
42971
42972 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42973 PyObject *resultobj = 0;
42974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42975 wxBitmap *arg2 = 0 ;
42976 void *argp1 = 0 ;
42977 int res1 = 0 ;
42978 void *argp2 = 0 ;
42979 int res2 = 0 ;
42980 PyObject * obj0 = 0 ;
42981 PyObject * obj1 = 0 ;
42982 char * kwnames[] = {
42983 (char *) "self",(char *) "bitmap", NULL
42984 };
42985
42986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42988 if (!SWIG_IsOK(res1)) {
42989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42990 }
42991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42993 if (!SWIG_IsOK(res2)) {
42994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42995 }
42996 if (!argp2) {
42997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42998 }
42999 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43000 {
43001 PyThreadState* __tstate = wxPyBeginAllowThreads();
43002 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43003 wxPyEndAllowThreads(__tstate);
43004 if (PyErr_Occurred()) SWIG_fail;
43005 }
43006 resultobj = SWIG_Py_Void();
43007 return resultobj;
43008 fail:
43009 return NULL;
43010 }
43011
43012
43013 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43014 PyObject *resultobj = 0;
43015 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43016 wxBitmap *result = 0 ;
43017 void *argp1 = 0 ;
43018 int res1 = 0 ;
43019 PyObject *swig_obj[1] ;
43020
43021 if (!args) SWIG_fail;
43022 swig_obj[0] = args;
43023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43024 if (!SWIG_IsOK(res1)) {
43025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43026 }
43027 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43028 {
43029 PyThreadState* __tstate = wxPyBeginAllowThreads();
43030 {
43031 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43032 result = (wxBitmap *) &_result_ref;
43033 }
43034 wxPyEndAllowThreads(__tstate);
43035 if (PyErr_Occurred()) SWIG_fail;
43036 }
43037 {
43038 wxBitmap* resultptr = new wxBitmap(*result);
43039 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43040 }
43041 return resultobj;
43042 fail:
43043 return NULL;
43044 }
43045
43046
43047 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43048 PyObject *resultobj = 0;
43049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43050 wxFont *arg2 = 0 ;
43051 void *argp1 = 0 ;
43052 int res1 = 0 ;
43053 void *argp2 = 0 ;
43054 int res2 = 0 ;
43055 PyObject * obj0 = 0 ;
43056 PyObject * obj1 = 0 ;
43057 char * kwnames[] = {
43058 (char *) "self",(char *) "font", NULL
43059 };
43060
43061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43068 if (!SWIG_IsOK(res2)) {
43069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43070 }
43071 if (!argp2) {
43072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43073 }
43074 arg2 = reinterpret_cast< wxFont * >(argp2);
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 (arg1)->SetFont((wxFont const &)*arg2);
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 resultobj = SWIG_Py_Void();
43082 return resultobj;
43083 fail:
43084 return NULL;
43085 }
43086
43087
43088 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43089 PyObject *resultobj = 0;
43090 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43091 wxFont result;
43092 void *argp1 = 0 ;
43093 int res1 = 0 ;
43094 PyObject *swig_obj[1] ;
43095
43096 if (!args) SWIG_fail;
43097 swig_obj[0] = args;
43098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43099 if (!SWIG_IsOK(res1)) {
43100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43101 }
43102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43103 {
43104 PyThreadState* __tstate = wxPyBeginAllowThreads();
43105 result = (arg1)->GetFont();
43106 wxPyEndAllowThreads(__tstate);
43107 if (PyErr_Occurred()) SWIG_fail;
43108 }
43109 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43117 PyObject *resultobj = 0;
43118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43119 wxColour *arg2 = 0 ;
43120 void *argp1 = 0 ;
43121 int res1 = 0 ;
43122 wxColour temp2 ;
43123 PyObject * obj0 = 0 ;
43124 PyObject * obj1 = 0 ;
43125 char * kwnames[] = {
43126 (char *) "self",(char *) "colText", NULL
43127 };
43128
43129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43131 if (!SWIG_IsOK(res1)) {
43132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43133 }
43134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43135 {
43136 arg2 = &temp2;
43137 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43138 }
43139 {
43140 PyThreadState* __tstate = wxPyBeginAllowThreads();
43141 (arg1)->SetTextColour((wxColour const &)*arg2);
43142 wxPyEndAllowThreads(__tstate);
43143 if (PyErr_Occurred()) SWIG_fail;
43144 }
43145 resultobj = SWIG_Py_Void();
43146 return resultobj;
43147 fail:
43148 return NULL;
43149 }
43150
43151
43152 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43153 PyObject *resultobj = 0;
43154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43155 wxColour result;
43156 void *argp1 = 0 ;
43157 int res1 = 0 ;
43158 PyObject *swig_obj[1] ;
43159
43160 if (!args) SWIG_fail;
43161 swig_obj[0] = args;
43162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43163 if (!SWIG_IsOK(res1)) {
43164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43165 }
43166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43167 {
43168 PyThreadState* __tstate = wxPyBeginAllowThreads();
43169 result = (arg1)->GetTextColour();
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43181 PyObject *resultobj = 0;
43182 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43183 wxColour *arg2 = 0 ;
43184 void *argp1 = 0 ;
43185 int res1 = 0 ;
43186 wxColour temp2 ;
43187 PyObject * obj0 = 0 ;
43188 PyObject * obj1 = 0 ;
43189 char * kwnames[] = {
43190 (char *) "self",(char *) "colBack", NULL
43191 };
43192
43193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43195 if (!SWIG_IsOK(res1)) {
43196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43197 }
43198 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43199 {
43200 arg2 = &temp2;
43201 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43202 }
43203 {
43204 PyThreadState* __tstate = wxPyBeginAllowThreads();
43205 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43206 wxPyEndAllowThreads(__tstate);
43207 if (PyErr_Occurred()) SWIG_fail;
43208 }
43209 resultobj = SWIG_Py_Void();
43210 return resultobj;
43211 fail:
43212 return NULL;
43213 }
43214
43215
43216 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43217 PyObject *resultobj = 0;
43218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43219 wxColour result;
43220 void *argp1 = 0 ;
43221 int res1 = 0 ;
43222 PyObject *swig_obj[1] ;
43223
43224 if (!args) SWIG_fail;
43225 swig_obj[0] = args;
43226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43227 if (!SWIG_IsOK(res1)) {
43228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43229 }
43230 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 result = (arg1)->GetBackgroundColour();
43234 wxPyEndAllowThreads(__tstate);
43235 if (PyErr_Occurred()) SWIG_fail;
43236 }
43237 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43238 return resultobj;
43239 fail:
43240 return NULL;
43241 }
43242
43243
43244 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43245 PyObject *resultobj = 0;
43246 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43247 wxBitmap *arg2 = 0 ;
43248 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43249 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43250 void *argp1 = 0 ;
43251 int res1 = 0 ;
43252 void *argp2 = 0 ;
43253 int res2 = 0 ;
43254 void *argp3 = 0 ;
43255 int res3 = 0 ;
43256 PyObject * obj0 = 0 ;
43257 PyObject * obj1 = 0 ;
43258 PyObject * obj2 = 0 ;
43259 char * kwnames[] = {
43260 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43261 };
43262
43263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43265 if (!SWIG_IsOK(res1)) {
43266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43267 }
43268 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43269 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43270 if (!SWIG_IsOK(res2)) {
43271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43272 }
43273 if (!argp2) {
43274 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43275 }
43276 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43277 if (obj2) {
43278 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43279 if (!SWIG_IsOK(res3)) {
43280 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43281 }
43282 if (!argp3) {
43283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43284 }
43285 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43286 }
43287 {
43288 PyThreadState* __tstate = wxPyBeginAllowThreads();
43289 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43290 wxPyEndAllowThreads(__tstate);
43291 if (PyErr_Occurred()) SWIG_fail;
43292 }
43293 resultobj = SWIG_Py_Void();
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43301 PyObject *resultobj = 0;
43302 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43303 wxBitmap *arg2 = 0 ;
43304 void *argp1 = 0 ;
43305 int res1 = 0 ;
43306 void *argp2 = 0 ;
43307 int res2 = 0 ;
43308 PyObject * obj0 = 0 ;
43309 PyObject * obj1 = 0 ;
43310 char * kwnames[] = {
43311 (char *) "self",(char *) "bmpDisabled", NULL
43312 };
43313
43314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43316 if (!SWIG_IsOK(res1)) {
43317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43318 }
43319 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43321 if (!SWIG_IsOK(res2)) {
43322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43323 }
43324 if (!argp2) {
43325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43326 }
43327 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43328 {
43329 PyThreadState* __tstate = wxPyBeginAllowThreads();
43330 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43331 wxPyEndAllowThreads(__tstate);
43332 if (PyErr_Occurred()) SWIG_fail;
43333 }
43334 resultobj = SWIG_Py_Void();
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43342 PyObject *resultobj = 0;
43343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43344 wxBitmap *result = 0 ;
43345 void *argp1 = 0 ;
43346 int res1 = 0 ;
43347 PyObject *swig_obj[1] ;
43348
43349 if (!args) SWIG_fail;
43350 swig_obj[0] = args;
43351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43352 if (!SWIG_IsOK(res1)) {
43353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43354 }
43355 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 {
43359 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43360 result = (wxBitmap *) &_result_ref;
43361 }
43362 wxPyEndAllowThreads(__tstate);
43363 if (PyErr_Occurred()) SWIG_fail;
43364 }
43365 {
43366 wxBitmap* resultptr = new wxBitmap(*result);
43367 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43368 }
43369 return resultobj;
43370 fail:
43371 return NULL;
43372 }
43373
43374
43375 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43376 PyObject *resultobj = 0;
43377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43378 int arg2 ;
43379 void *argp1 = 0 ;
43380 int res1 = 0 ;
43381 int val2 ;
43382 int ecode2 = 0 ;
43383 PyObject * obj0 = 0 ;
43384 PyObject * obj1 = 0 ;
43385 char * kwnames[] = {
43386 (char *) "self",(char *) "nWidth", NULL
43387 };
43388
43389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43391 if (!SWIG_IsOK(res1)) {
43392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43393 }
43394 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43395 ecode2 = SWIG_AsVal_int(obj1, &val2);
43396 if (!SWIG_IsOK(ecode2)) {
43397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43398 }
43399 arg2 = static_cast< int >(val2);
43400 {
43401 PyThreadState* __tstate = wxPyBeginAllowThreads();
43402 (arg1)->SetMarginWidth(arg2);
43403 wxPyEndAllowThreads(__tstate);
43404 if (PyErr_Occurred()) SWIG_fail;
43405 }
43406 resultobj = SWIG_Py_Void();
43407 return resultobj;
43408 fail:
43409 return NULL;
43410 }
43411
43412
43413 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43414 PyObject *resultobj = 0;
43415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43416 int result;
43417 void *argp1 = 0 ;
43418 int res1 = 0 ;
43419 PyObject *swig_obj[1] ;
43420
43421 if (!args) SWIG_fail;
43422 swig_obj[0] = args;
43423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43424 if (!SWIG_IsOK(res1)) {
43425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43426 }
43427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 result = (int)(arg1)->GetMarginWidth();
43431 wxPyEndAllowThreads(__tstate);
43432 if (PyErr_Occurred()) SWIG_fail;
43433 }
43434 resultobj = SWIG_From_int(static_cast< int >(result));
43435 return resultobj;
43436 fail:
43437 return NULL;
43438 }
43439
43440
43441 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43442 PyObject *resultobj = 0;
43443 int result;
43444
43445 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 result = (int)wxMenuItem::GetDefaultMarginWidth();
43449 wxPyEndAllowThreads(__tstate);
43450 if (PyErr_Occurred()) SWIG_fail;
43451 }
43452 resultobj = SWIG_From_int(static_cast< int >(result));
43453 return resultobj;
43454 fail:
43455 return NULL;
43456 }
43457
43458
43459 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43460 PyObject *resultobj = 0;
43461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43462 bool result;
43463 void *argp1 = 0 ;
43464 int res1 = 0 ;
43465 PyObject *swig_obj[1] ;
43466
43467 if (!args) SWIG_fail;
43468 swig_obj[0] = args;
43469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43470 if (!SWIG_IsOK(res1)) {
43471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43472 }
43473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43474 {
43475 PyThreadState* __tstate = wxPyBeginAllowThreads();
43476 result = (bool)(arg1)->IsOwnerDrawn();
43477 wxPyEndAllowThreads(__tstate);
43478 if (PyErr_Occurred()) SWIG_fail;
43479 }
43480 {
43481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43482 }
43483 return resultobj;
43484 fail:
43485 return NULL;
43486 }
43487
43488
43489 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43490 PyObject *resultobj = 0;
43491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43492 bool arg2 = (bool) true ;
43493 void *argp1 = 0 ;
43494 int res1 = 0 ;
43495 bool val2 ;
43496 int ecode2 = 0 ;
43497 PyObject * obj0 = 0 ;
43498 PyObject * obj1 = 0 ;
43499 char * kwnames[] = {
43500 (char *) "self",(char *) "ownerDrawn", NULL
43501 };
43502
43503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43505 if (!SWIG_IsOK(res1)) {
43506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43507 }
43508 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43509 if (obj1) {
43510 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43511 if (!SWIG_IsOK(ecode2)) {
43512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43513 }
43514 arg2 = static_cast< bool >(val2);
43515 }
43516 {
43517 PyThreadState* __tstate = wxPyBeginAllowThreads();
43518 (arg1)->SetOwnerDrawn(arg2);
43519 wxPyEndAllowThreads(__tstate);
43520 if (PyErr_Occurred()) SWIG_fail;
43521 }
43522 resultobj = SWIG_Py_Void();
43523 return resultobj;
43524 fail:
43525 return NULL;
43526 }
43527
43528
43529 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43530 PyObject *resultobj = 0;
43531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43532 void *argp1 = 0 ;
43533 int res1 = 0 ;
43534 PyObject *swig_obj[1] ;
43535
43536 if (!args) SWIG_fail;
43537 swig_obj[0] = args;
43538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43539 if (!SWIG_IsOK(res1)) {
43540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43541 }
43542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43543 {
43544 PyThreadState* __tstate = wxPyBeginAllowThreads();
43545 (arg1)->ResetOwnerDrawn();
43546 wxPyEndAllowThreads(__tstate);
43547 if (PyErr_Occurred()) SWIG_fail;
43548 }
43549 resultobj = SWIG_Py_Void();
43550 return resultobj;
43551 fail:
43552 return NULL;
43553 }
43554
43555
43556 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43557 PyObject *obj;
43558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43559 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43560 return SWIG_Py_Void();
43561 }
43562
43563 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43564 return SWIG_Python_InitShadowInstance(args);
43565 }
43566
43567 SWIGINTERN int ControlNameStr_set(PyObject *) {
43568 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43569 return 1;
43570 }
43571
43572
43573 SWIGINTERN PyObject *ControlNameStr_get(void) {
43574 PyObject *pyobj = 0;
43575
43576 {
43577 #if wxUSE_UNICODE
43578 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43579 #else
43580 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43581 #endif
43582 }
43583 return pyobj;
43584 }
43585
43586
43587 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43588 PyObject *resultobj = 0;
43589 wxWindow *arg1 = (wxWindow *) 0 ;
43590 int arg2 = (int) -1 ;
43591 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43592 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43593 wxSize const &arg4_defvalue = wxDefaultSize ;
43594 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43595 long arg5 = (long) 0 ;
43596 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43597 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43598 wxString const &arg7_defvalue = wxPyControlNameStr ;
43599 wxString *arg7 = (wxString *) &arg7_defvalue ;
43600 wxControl *result = 0 ;
43601 void *argp1 = 0 ;
43602 int res1 = 0 ;
43603 int val2 ;
43604 int ecode2 = 0 ;
43605 wxPoint temp3 ;
43606 wxSize temp4 ;
43607 long val5 ;
43608 int ecode5 = 0 ;
43609 void *argp6 = 0 ;
43610 int res6 = 0 ;
43611 bool temp7 = false ;
43612 PyObject * obj0 = 0 ;
43613 PyObject * obj1 = 0 ;
43614 PyObject * obj2 = 0 ;
43615 PyObject * obj3 = 0 ;
43616 PyObject * obj4 = 0 ;
43617 PyObject * obj5 = 0 ;
43618 PyObject * obj6 = 0 ;
43619 char * kwnames[] = {
43620 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43621 };
43622
43623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43625 if (!SWIG_IsOK(res1)) {
43626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43627 }
43628 arg1 = reinterpret_cast< wxWindow * >(argp1);
43629 if (obj1) {
43630 ecode2 = SWIG_AsVal_int(obj1, &val2);
43631 if (!SWIG_IsOK(ecode2)) {
43632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43633 }
43634 arg2 = static_cast< int >(val2);
43635 }
43636 if (obj2) {
43637 {
43638 arg3 = &temp3;
43639 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43640 }
43641 }
43642 if (obj3) {
43643 {
43644 arg4 = &temp4;
43645 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43646 }
43647 }
43648 if (obj4) {
43649 ecode5 = SWIG_AsVal_long(obj4, &val5);
43650 if (!SWIG_IsOK(ecode5)) {
43651 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43652 }
43653 arg5 = static_cast< long >(val5);
43654 }
43655 if (obj5) {
43656 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43657 if (!SWIG_IsOK(res6)) {
43658 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43659 }
43660 if (!argp6) {
43661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43662 }
43663 arg6 = reinterpret_cast< wxValidator * >(argp6);
43664 }
43665 if (obj6) {
43666 {
43667 arg7 = wxString_in_helper(obj6);
43668 if (arg7 == NULL) SWIG_fail;
43669 temp7 = true;
43670 }
43671 }
43672 {
43673 if (!wxPyCheckForApp()) SWIG_fail;
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43676 wxPyEndAllowThreads(__tstate);
43677 if (PyErr_Occurred()) SWIG_fail;
43678 }
43679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43680 {
43681 if (temp7)
43682 delete arg7;
43683 }
43684 return resultobj;
43685 fail:
43686 {
43687 if (temp7)
43688 delete arg7;
43689 }
43690 return NULL;
43691 }
43692
43693
43694 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43695 PyObject *resultobj = 0;
43696 wxControl *result = 0 ;
43697
43698 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43699 {
43700 if (!wxPyCheckForApp()) SWIG_fail;
43701 PyThreadState* __tstate = wxPyBeginAllowThreads();
43702 result = (wxControl *)new wxControl();
43703 wxPyEndAllowThreads(__tstate);
43704 if (PyErr_Occurred()) SWIG_fail;
43705 }
43706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43707 return resultobj;
43708 fail:
43709 return NULL;
43710 }
43711
43712
43713 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43714 PyObject *resultobj = 0;
43715 wxControl *arg1 = (wxControl *) 0 ;
43716 wxWindow *arg2 = (wxWindow *) 0 ;
43717 int arg3 = (int) -1 ;
43718 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43719 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43720 wxSize const &arg5_defvalue = wxDefaultSize ;
43721 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43722 long arg6 = (long) 0 ;
43723 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43724 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43725 wxString const &arg8_defvalue = wxPyControlNameStr ;
43726 wxString *arg8 = (wxString *) &arg8_defvalue ;
43727 bool result;
43728 void *argp1 = 0 ;
43729 int res1 = 0 ;
43730 void *argp2 = 0 ;
43731 int res2 = 0 ;
43732 int val3 ;
43733 int ecode3 = 0 ;
43734 wxPoint temp4 ;
43735 wxSize temp5 ;
43736 long val6 ;
43737 int ecode6 = 0 ;
43738 void *argp7 = 0 ;
43739 int res7 = 0 ;
43740 bool temp8 = false ;
43741 PyObject * obj0 = 0 ;
43742 PyObject * obj1 = 0 ;
43743 PyObject * obj2 = 0 ;
43744 PyObject * obj3 = 0 ;
43745 PyObject * obj4 = 0 ;
43746 PyObject * obj5 = 0 ;
43747 PyObject * obj6 = 0 ;
43748 PyObject * obj7 = 0 ;
43749 char * kwnames[] = {
43750 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43751 };
43752
43753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43757 }
43758 arg1 = reinterpret_cast< wxControl * >(argp1);
43759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43760 if (!SWIG_IsOK(res2)) {
43761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43762 }
43763 arg2 = reinterpret_cast< wxWindow * >(argp2);
43764 if (obj2) {
43765 ecode3 = SWIG_AsVal_int(obj2, &val3);
43766 if (!SWIG_IsOK(ecode3)) {
43767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43768 }
43769 arg3 = static_cast< int >(val3);
43770 }
43771 if (obj3) {
43772 {
43773 arg4 = &temp4;
43774 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43775 }
43776 }
43777 if (obj4) {
43778 {
43779 arg5 = &temp5;
43780 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43781 }
43782 }
43783 if (obj5) {
43784 ecode6 = SWIG_AsVal_long(obj5, &val6);
43785 if (!SWIG_IsOK(ecode6)) {
43786 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43787 }
43788 arg6 = static_cast< long >(val6);
43789 }
43790 if (obj6) {
43791 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43792 if (!SWIG_IsOK(res7)) {
43793 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43794 }
43795 if (!argp7) {
43796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43797 }
43798 arg7 = reinterpret_cast< wxValidator * >(argp7);
43799 }
43800 if (obj7) {
43801 {
43802 arg8 = wxString_in_helper(obj7);
43803 if (arg8 == NULL) SWIG_fail;
43804 temp8 = true;
43805 }
43806 }
43807 {
43808 PyThreadState* __tstate = wxPyBeginAllowThreads();
43809 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43810 wxPyEndAllowThreads(__tstate);
43811 if (PyErr_Occurred()) SWIG_fail;
43812 }
43813 {
43814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43815 }
43816 {
43817 if (temp8)
43818 delete arg8;
43819 }
43820 return resultobj;
43821 fail:
43822 {
43823 if (temp8)
43824 delete arg8;
43825 }
43826 return NULL;
43827 }
43828
43829
43830 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43831 PyObject *resultobj = 0;
43832 wxControl *arg1 = (wxControl *) 0 ;
43833 wxCommandEvent *arg2 = 0 ;
43834 void *argp1 = 0 ;
43835 int res1 = 0 ;
43836 void *argp2 = 0 ;
43837 int res2 = 0 ;
43838 PyObject * obj0 = 0 ;
43839 PyObject * obj1 = 0 ;
43840 char * kwnames[] = {
43841 (char *) "self",(char *) "event", NULL
43842 };
43843
43844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43846 if (!SWIG_IsOK(res1)) {
43847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43848 }
43849 arg1 = reinterpret_cast< wxControl * >(argp1);
43850 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43851 if (!SWIG_IsOK(res2)) {
43852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43853 }
43854 if (!argp2) {
43855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43856 }
43857 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43858 {
43859 PyThreadState* __tstate = wxPyBeginAllowThreads();
43860 (arg1)->Command(*arg2);
43861 wxPyEndAllowThreads(__tstate);
43862 if (PyErr_Occurred()) SWIG_fail;
43863 }
43864 resultobj = SWIG_Py_Void();
43865 return resultobj;
43866 fail:
43867 return NULL;
43868 }
43869
43870
43871 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43872 PyObject *resultobj = 0;
43873 wxControl *arg1 = (wxControl *) 0 ;
43874 wxString result;
43875 void *argp1 = 0 ;
43876 int res1 = 0 ;
43877 PyObject *swig_obj[1] ;
43878
43879 if (!args) SWIG_fail;
43880 swig_obj[0] = args;
43881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43882 if (!SWIG_IsOK(res1)) {
43883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43884 }
43885 arg1 = reinterpret_cast< wxControl * >(argp1);
43886 {
43887 PyThreadState* __tstate = wxPyBeginAllowThreads();
43888 result = (arg1)->GetLabel();
43889 wxPyEndAllowThreads(__tstate);
43890 if (PyErr_Occurred()) SWIG_fail;
43891 }
43892 {
43893 #if wxUSE_UNICODE
43894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43895 #else
43896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43897 #endif
43898 }
43899 return resultobj;
43900 fail:
43901 return NULL;
43902 }
43903
43904
43905 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43906 PyObject *resultobj = 0;
43907 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43908 SwigValueWrapper<wxVisualAttributes > result;
43909 int val1 ;
43910 int ecode1 = 0 ;
43911 PyObject * obj0 = 0 ;
43912 char * kwnames[] = {
43913 (char *) "variant", NULL
43914 };
43915
43916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43917 if (obj0) {
43918 ecode1 = SWIG_AsVal_int(obj0, &val1);
43919 if (!SWIG_IsOK(ecode1)) {
43920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43921 }
43922 arg1 = static_cast< wxWindowVariant >(val1);
43923 }
43924 {
43925 if (!wxPyCheckForApp()) SWIG_fail;
43926 PyThreadState* __tstate = wxPyBeginAllowThreads();
43927 result = wxControl::GetClassDefaultAttributes(arg1);
43928 wxPyEndAllowThreads(__tstate);
43929 if (PyErr_Occurred()) SWIG_fail;
43930 }
43931 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43939 PyObject *obj;
43940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43941 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43942 return SWIG_Py_Void();
43943 }
43944
43945 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43946 return SWIG_Python_InitShadowInstance(args);
43947 }
43948
43949 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43950 PyObject *resultobj = 0;
43951 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43952 wxString *arg2 = 0 ;
43953 PyObject *arg3 = (PyObject *) NULL ;
43954 int result;
43955 void *argp1 = 0 ;
43956 int res1 = 0 ;
43957 bool temp2 = false ;
43958 PyObject * obj0 = 0 ;
43959 PyObject * obj1 = 0 ;
43960 PyObject * obj2 = 0 ;
43961 char * kwnames[] = {
43962 (char *) "self",(char *) "item",(char *) "clientData", NULL
43963 };
43964
43965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43967 if (!SWIG_IsOK(res1)) {
43968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43969 }
43970 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43971 {
43972 arg2 = wxString_in_helper(obj1);
43973 if (arg2 == NULL) SWIG_fail;
43974 temp2 = true;
43975 }
43976 if (obj2) {
43977 arg3 = obj2;
43978 }
43979 {
43980 PyThreadState* __tstate = wxPyBeginAllowThreads();
43981 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43982 wxPyEndAllowThreads(__tstate);
43983 if (PyErr_Occurred()) SWIG_fail;
43984 }
43985 resultobj = SWIG_From_int(static_cast< int >(result));
43986 {
43987 if (temp2)
43988 delete arg2;
43989 }
43990 return resultobj;
43991 fail:
43992 {
43993 if (temp2)
43994 delete arg2;
43995 }
43996 return NULL;
43997 }
43998
43999
44000 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = 0;
44002 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44003 wxArrayString *arg2 = 0 ;
44004 void *argp1 = 0 ;
44005 int res1 = 0 ;
44006 bool temp2 = false ;
44007 PyObject * obj0 = 0 ;
44008 PyObject * obj1 = 0 ;
44009 char * kwnames[] = {
44010 (char *) "self",(char *) "strings", NULL
44011 };
44012
44013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44015 if (!SWIG_IsOK(res1)) {
44016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44017 }
44018 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44019 {
44020 if (! PySequence_Check(obj1)) {
44021 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44022 SWIG_fail;
44023 }
44024 arg2 = new wxArrayString;
44025 temp2 = true;
44026 int i, len=PySequence_Length(obj1);
44027 for (i=0; i<len; i++) {
44028 PyObject* item = PySequence_GetItem(obj1, i);
44029 wxString* s = wxString_in_helper(item);
44030 if (PyErr_Occurred()) SWIG_fail;
44031 arg2->Add(*s);
44032 delete s;
44033 Py_DECREF(item);
44034 }
44035 }
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 (arg1)->Append((wxArrayString const &)*arg2);
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 resultobj = SWIG_Py_Void();
44043 {
44044 if (temp2) delete arg2;
44045 }
44046 return resultobj;
44047 fail:
44048 {
44049 if (temp2) delete arg2;
44050 }
44051 return NULL;
44052 }
44053
44054
44055 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44056 PyObject *resultobj = 0;
44057 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44058 wxString *arg2 = 0 ;
44059 unsigned int arg3 ;
44060 PyObject *arg4 = (PyObject *) NULL ;
44061 int result;
44062 void *argp1 = 0 ;
44063 int res1 = 0 ;
44064 bool temp2 = false ;
44065 unsigned int val3 ;
44066 int ecode3 = 0 ;
44067 PyObject * obj0 = 0 ;
44068 PyObject * obj1 = 0 ;
44069 PyObject * obj2 = 0 ;
44070 PyObject * obj3 = 0 ;
44071 char * kwnames[] = {
44072 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44073 };
44074
44075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44077 if (!SWIG_IsOK(res1)) {
44078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44079 }
44080 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44081 {
44082 arg2 = wxString_in_helper(obj1);
44083 if (arg2 == NULL) SWIG_fail;
44084 temp2 = true;
44085 }
44086 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44087 if (!SWIG_IsOK(ecode3)) {
44088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44089 }
44090 arg3 = static_cast< unsigned int >(val3);
44091 if (obj3) {
44092 arg4 = obj3;
44093 }
44094 {
44095 PyThreadState* __tstate = wxPyBeginAllowThreads();
44096 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44097 wxPyEndAllowThreads(__tstate);
44098 if (PyErr_Occurred()) SWIG_fail;
44099 }
44100 resultobj = SWIG_From_int(static_cast< int >(result));
44101 {
44102 if (temp2)
44103 delete arg2;
44104 }
44105 return resultobj;
44106 fail:
44107 {
44108 if (temp2)
44109 delete arg2;
44110 }
44111 return NULL;
44112 }
44113
44114
44115 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44116 PyObject *resultobj = 0;
44117 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44118 void *argp1 = 0 ;
44119 int res1 = 0 ;
44120 PyObject *swig_obj[1] ;
44121
44122 if (!args) SWIG_fail;
44123 swig_obj[0] = args;
44124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44125 if (!SWIG_IsOK(res1)) {
44126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44127 }
44128 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 (arg1)->Clear();
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 resultobj = SWIG_Py_Void();
44136 return resultobj;
44137 fail:
44138 return NULL;
44139 }
44140
44141
44142 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44143 PyObject *resultobj = 0;
44144 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44145 unsigned int arg2 ;
44146 void *argp1 = 0 ;
44147 int res1 = 0 ;
44148 unsigned int val2 ;
44149 int ecode2 = 0 ;
44150 PyObject * obj0 = 0 ;
44151 PyObject * obj1 = 0 ;
44152 char * kwnames[] = {
44153 (char *) "self",(char *) "n", NULL
44154 };
44155
44156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44158 if (!SWIG_IsOK(res1)) {
44159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44160 }
44161 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44162 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44163 if (!SWIG_IsOK(ecode2)) {
44164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44165 }
44166 arg2 = static_cast< unsigned int >(val2);
44167 {
44168 PyThreadState* __tstate = wxPyBeginAllowThreads();
44169 (arg1)->Delete(arg2);
44170 wxPyEndAllowThreads(__tstate);
44171 if (PyErr_Occurred()) SWIG_fail;
44172 }
44173 resultobj = SWIG_Py_Void();
44174 return resultobj;
44175 fail:
44176 return NULL;
44177 }
44178
44179
44180 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44181 PyObject *resultobj = 0;
44182 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44183 unsigned int arg2 ;
44184 PyObject *result = 0 ;
44185 void *argp1 = 0 ;
44186 int res1 = 0 ;
44187 unsigned int val2 ;
44188 int ecode2 = 0 ;
44189 PyObject * obj0 = 0 ;
44190 PyObject * obj1 = 0 ;
44191 char * kwnames[] = {
44192 (char *) "self",(char *) "n", NULL
44193 };
44194
44195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44197 if (!SWIG_IsOK(res1)) {
44198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44199 }
44200 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44201 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44202 if (!SWIG_IsOK(ecode2)) {
44203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44204 }
44205 arg2 = static_cast< unsigned int >(val2);
44206 {
44207 PyThreadState* __tstate = wxPyBeginAllowThreads();
44208 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44209 wxPyEndAllowThreads(__tstate);
44210 if (PyErr_Occurred()) SWIG_fail;
44211 }
44212 resultobj = result;
44213 return resultobj;
44214 fail:
44215 return NULL;
44216 }
44217
44218
44219 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44220 PyObject *resultobj = 0;
44221 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44222 unsigned int arg2 ;
44223 PyObject *arg3 = (PyObject *) 0 ;
44224 void *argp1 = 0 ;
44225 int res1 = 0 ;
44226 unsigned int val2 ;
44227 int ecode2 = 0 ;
44228 PyObject * obj0 = 0 ;
44229 PyObject * obj1 = 0 ;
44230 PyObject * obj2 = 0 ;
44231 char * kwnames[] = {
44232 (char *) "self",(char *) "n",(char *) "clientData", NULL
44233 };
44234
44235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44237 if (!SWIG_IsOK(res1)) {
44238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44239 }
44240 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44241 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44242 if (!SWIG_IsOK(ecode2)) {
44243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44244 }
44245 arg2 = static_cast< unsigned int >(val2);
44246 arg3 = obj2;
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 wxItemContainer_SetClientData(arg1,arg2,arg3);
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 resultobj = SWIG_Py_Void();
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44261 PyObject *resultobj = 0;
44262 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44263 unsigned int result;
44264 void *argp1 = 0 ;
44265 int res1 = 0 ;
44266 PyObject *swig_obj[1] ;
44267
44268 if (!args) SWIG_fail;
44269 swig_obj[0] = args;
44270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44271 if (!SWIG_IsOK(res1)) {
44272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44273 }
44274 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44282 return resultobj;
44283 fail:
44284 return NULL;
44285 }
44286
44287
44288 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44289 PyObject *resultobj = 0;
44290 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44291 bool result;
44292 void *argp1 = 0 ;
44293 int res1 = 0 ;
44294 PyObject *swig_obj[1] ;
44295
44296 if (!args) SWIG_fail;
44297 swig_obj[0] = args;
44298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44299 if (!SWIG_IsOK(res1)) {
44300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44301 }
44302 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44303 {
44304 PyThreadState* __tstate = wxPyBeginAllowThreads();
44305 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44306 wxPyEndAllowThreads(__tstate);
44307 if (PyErr_Occurred()) SWIG_fail;
44308 }
44309 {
44310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44311 }
44312 return resultobj;
44313 fail:
44314 return NULL;
44315 }
44316
44317
44318 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44319 PyObject *resultobj = 0;
44320 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44321 unsigned int arg2 ;
44322 wxString result;
44323 void *argp1 = 0 ;
44324 int res1 = 0 ;
44325 unsigned int val2 ;
44326 int ecode2 = 0 ;
44327 PyObject * obj0 = 0 ;
44328 PyObject * obj1 = 0 ;
44329 char * kwnames[] = {
44330 (char *) "self",(char *) "n", NULL
44331 };
44332
44333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44335 if (!SWIG_IsOK(res1)) {
44336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44337 }
44338 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44339 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44340 if (!SWIG_IsOK(ecode2)) {
44341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44342 }
44343 arg2 = static_cast< unsigned int >(val2);
44344 {
44345 PyThreadState* __tstate = wxPyBeginAllowThreads();
44346 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44347 wxPyEndAllowThreads(__tstate);
44348 if (PyErr_Occurred()) SWIG_fail;
44349 }
44350 {
44351 #if wxUSE_UNICODE
44352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44353 #else
44354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44355 #endif
44356 }
44357 return resultobj;
44358 fail:
44359 return NULL;
44360 }
44361
44362
44363 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44364 PyObject *resultobj = 0;
44365 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44366 wxArrayString result;
44367 void *argp1 = 0 ;
44368 int res1 = 0 ;
44369 PyObject *swig_obj[1] ;
44370
44371 if (!args) SWIG_fail;
44372 swig_obj[0] = args;
44373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44374 if (!SWIG_IsOK(res1)) {
44375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44376 }
44377 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 result = ((wxItemContainer const *)arg1)->GetStrings();
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 {
44385 resultobj = wxArrayString2PyList_helper(result);
44386 }
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj = 0;
44395 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44396 unsigned int arg2 ;
44397 wxString *arg3 = 0 ;
44398 void *argp1 = 0 ;
44399 int res1 = 0 ;
44400 unsigned int val2 ;
44401 int ecode2 = 0 ;
44402 bool temp3 = false ;
44403 PyObject * obj0 = 0 ;
44404 PyObject * obj1 = 0 ;
44405 PyObject * obj2 = 0 ;
44406 char * kwnames[] = {
44407 (char *) "self",(char *) "n",(char *) "s", NULL
44408 };
44409
44410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44412 if (!SWIG_IsOK(res1)) {
44413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44414 }
44415 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44416 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44417 if (!SWIG_IsOK(ecode2)) {
44418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44419 }
44420 arg2 = static_cast< unsigned int >(val2);
44421 {
44422 arg3 = wxString_in_helper(obj2);
44423 if (arg3 == NULL) SWIG_fail;
44424 temp3 = true;
44425 }
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 (arg1)->SetString(arg2,(wxString const &)*arg3);
44429 wxPyEndAllowThreads(__tstate);
44430 if (PyErr_Occurred()) SWIG_fail;
44431 }
44432 resultobj = SWIG_Py_Void();
44433 {
44434 if (temp3)
44435 delete arg3;
44436 }
44437 return resultobj;
44438 fail:
44439 {
44440 if (temp3)
44441 delete arg3;
44442 }
44443 return NULL;
44444 }
44445
44446
44447 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj = 0;
44449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44450 wxString *arg2 = 0 ;
44451 int result;
44452 void *argp1 = 0 ;
44453 int res1 = 0 ;
44454 bool temp2 = false ;
44455 PyObject * obj0 = 0 ;
44456 PyObject * obj1 = 0 ;
44457 char * kwnames[] = {
44458 (char *) "self",(char *) "s", NULL
44459 };
44460
44461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44463 if (!SWIG_IsOK(res1)) {
44464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44465 }
44466 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44467 {
44468 arg2 = wxString_in_helper(obj1);
44469 if (arg2 == NULL) SWIG_fail;
44470 temp2 = true;
44471 }
44472 {
44473 PyThreadState* __tstate = wxPyBeginAllowThreads();
44474 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44475 wxPyEndAllowThreads(__tstate);
44476 if (PyErr_Occurred()) SWIG_fail;
44477 }
44478 resultobj = SWIG_From_int(static_cast< int >(result));
44479 {
44480 if (temp2)
44481 delete arg2;
44482 }
44483 return resultobj;
44484 fail:
44485 {
44486 if (temp2)
44487 delete arg2;
44488 }
44489 return NULL;
44490 }
44491
44492
44493 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44494 PyObject *resultobj = 0;
44495 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44496 int arg2 ;
44497 void *argp1 = 0 ;
44498 int res1 = 0 ;
44499 int val2 ;
44500 int ecode2 = 0 ;
44501 PyObject * obj0 = 0 ;
44502 PyObject * obj1 = 0 ;
44503 char * kwnames[] = {
44504 (char *) "self",(char *) "n", NULL
44505 };
44506
44507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44509 if (!SWIG_IsOK(res1)) {
44510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44511 }
44512 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44513 ecode2 = SWIG_AsVal_int(obj1, &val2);
44514 if (!SWIG_IsOK(ecode2)) {
44515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44516 }
44517 arg2 = static_cast< int >(val2);
44518 {
44519 PyThreadState* __tstate = wxPyBeginAllowThreads();
44520 (arg1)->SetSelection(arg2);
44521 wxPyEndAllowThreads(__tstate);
44522 if (PyErr_Occurred()) SWIG_fail;
44523 }
44524 resultobj = SWIG_Py_Void();
44525 return resultobj;
44526 fail:
44527 return NULL;
44528 }
44529
44530
44531 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44532 PyObject *resultobj = 0;
44533 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44534 int result;
44535 void *argp1 = 0 ;
44536 int res1 = 0 ;
44537 PyObject *swig_obj[1] ;
44538
44539 if (!args) SWIG_fail;
44540 swig_obj[0] = args;
44541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44542 if (!SWIG_IsOK(res1)) {
44543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44544 }
44545 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44546 {
44547 PyThreadState* __tstate = wxPyBeginAllowThreads();
44548 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 resultobj = SWIG_From_int(static_cast< int >(result));
44553 return resultobj;
44554 fail:
44555 return NULL;
44556 }
44557
44558
44559 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44560 PyObject *resultobj = 0;
44561 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44562 wxString *arg2 = 0 ;
44563 bool result;
44564 void *argp1 = 0 ;
44565 int res1 = 0 ;
44566 bool temp2 = false ;
44567 PyObject * obj0 = 0 ;
44568 PyObject * obj1 = 0 ;
44569 char * kwnames[] = {
44570 (char *) "self",(char *) "s", NULL
44571 };
44572
44573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44575 if (!SWIG_IsOK(res1)) {
44576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44577 }
44578 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44579 {
44580 arg2 = wxString_in_helper(obj1);
44581 if (arg2 == NULL) SWIG_fail;
44582 temp2 = true;
44583 }
44584 {
44585 PyThreadState* __tstate = wxPyBeginAllowThreads();
44586 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44587 wxPyEndAllowThreads(__tstate);
44588 if (PyErr_Occurred()) SWIG_fail;
44589 }
44590 {
44591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44592 }
44593 {
44594 if (temp2)
44595 delete arg2;
44596 }
44597 return resultobj;
44598 fail:
44599 {
44600 if (temp2)
44601 delete arg2;
44602 }
44603 return NULL;
44604 }
44605
44606
44607 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44608 PyObject *resultobj = 0;
44609 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44610 wxString result;
44611 void *argp1 = 0 ;
44612 int res1 = 0 ;
44613 PyObject *swig_obj[1] ;
44614
44615 if (!args) SWIG_fail;
44616 swig_obj[0] = args;
44617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44618 if (!SWIG_IsOK(res1)) {
44619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44620 }
44621 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44622 {
44623 PyThreadState* __tstate = wxPyBeginAllowThreads();
44624 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 {
44629 #if wxUSE_UNICODE
44630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44631 #else
44632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44633 #endif
44634 }
44635 return resultobj;
44636 fail:
44637 return NULL;
44638 }
44639
44640
44641 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44642 PyObject *resultobj = 0;
44643 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44644 int arg2 ;
44645 void *argp1 = 0 ;
44646 int res1 = 0 ;
44647 int val2 ;
44648 int ecode2 = 0 ;
44649 PyObject * obj0 = 0 ;
44650 PyObject * obj1 = 0 ;
44651 char * kwnames[] = {
44652 (char *) "self",(char *) "n", NULL
44653 };
44654
44655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44657 if (!SWIG_IsOK(res1)) {
44658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44659 }
44660 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44661 ecode2 = SWIG_AsVal_int(obj1, &val2);
44662 if (!SWIG_IsOK(ecode2)) {
44663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44664 }
44665 arg2 = static_cast< int >(val2);
44666 {
44667 PyThreadState* __tstate = wxPyBeginAllowThreads();
44668 (arg1)->Select(arg2);
44669 wxPyEndAllowThreads(__tstate);
44670 if (PyErr_Occurred()) SWIG_fail;
44671 }
44672 resultobj = SWIG_Py_Void();
44673 return resultobj;
44674 fail:
44675 return NULL;
44676 }
44677
44678
44679 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44680 PyObject *obj;
44681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44682 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44683 return SWIG_Py_Void();
44684 }
44685
44686 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44687 PyObject *obj;
44688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44689 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44690 return SWIG_Py_Void();
44691 }
44692
44693 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44694 PyObject *resultobj = 0;
44695 wxSizerItem *result = 0 ;
44696
44697 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44698 {
44699 PyThreadState* __tstate = wxPyBeginAllowThreads();
44700 result = (wxSizerItem *)new wxSizerItem();
44701 wxPyEndAllowThreads(__tstate);
44702 if (PyErr_Occurred()) SWIG_fail;
44703 }
44704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44705 return resultobj;
44706 fail:
44707 return NULL;
44708 }
44709
44710
44711 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44712 PyObject *resultobj = 0;
44713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44714 void *argp1 = 0 ;
44715 int res1 = 0 ;
44716 PyObject *swig_obj[1] ;
44717
44718 if (!args) SWIG_fail;
44719 swig_obj[0] = args;
44720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44721 if (!SWIG_IsOK(res1)) {
44722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44723 }
44724 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44725 {
44726 PyThreadState* __tstate = wxPyBeginAllowThreads();
44727 delete arg1;
44728
44729 wxPyEndAllowThreads(__tstate);
44730 if (PyErr_Occurred()) SWIG_fail;
44731 }
44732 resultobj = SWIG_Py_Void();
44733 return resultobj;
44734 fail:
44735 return NULL;
44736 }
44737
44738
44739 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44740 PyObject *resultobj = 0;
44741 wxWindow *arg1 = (wxWindow *) 0 ;
44742 int arg2 ;
44743 int arg3 ;
44744 int arg4 ;
44745 PyObject *arg5 = (PyObject *) NULL ;
44746 wxSizerItem *result = 0 ;
44747 void *argp1 = 0 ;
44748 int res1 = 0 ;
44749 int val2 ;
44750 int ecode2 = 0 ;
44751 int val3 ;
44752 int ecode3 = 0 ;
44753 int val4 ;
44754 int ecode4 = 0 ;
44755 PyObject * obj0 = 0 ;
44756 PyObject * obj1 = 0 ;
44757 PyObject * obj2 = 0 ;
44758 PyObject * obj3 = 0 ;
44759 PyObject * obj4 = 0 ;
44760 char * kwnames[] = {
44761 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44762 };
44763
44764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44766 if (!SWIG_IsOK(res1)) {
44767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44768 }
44769 arg1 = reinterpret_cast< wxWindow * >(argp1);
44770 ecode2 = SWIG_AsVal_int(obj1, &val2);
44771 if (!SWIG_IsOK(ecode2)) {
44772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44773 }
44774 arg2 = static_cast< int >(val2);
44775 ecode3 = SWIG_AsVal_int(obj2, &val3);
44776 if (!SWIG_IsOK(ecode3)) {
44777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44778 }
44779 arg3 = static_cast< int >(val3);
44780 ecode4 = SWIG_AsVal_int(obj3, &val4);
44781 if (!SWIG_IsOK(ecode4)) {
44782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44783 }
44784 arg4 = static_cast< int >(val4);
44785 if (obj4) {
44786 arg5 = obj4;
44787 }
44788 {
44789 PyThreadState* __tstate = wxPyBeginAllowThreads();
44790 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44791 wxPyEndAllowThreads(__tstate);
44792 if (PyErr_Occurred()) SWIG_fail;
44793 }
44794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44795 return resultobj;
44796 fail:
44797 return NULL;
44798 }
44799
44800
44801 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44802 PyObject *resultobj = 0;
44803 int arg1 ;
44804 int arg2 ;
44805 int arg3 ;
44806 int arg4 ;
44807 int arg5 ;
44808 PyObject *arg6 = (PyObject *) NULL ;
44809 wxSizerItem *result = 0 ;
44810 int val1 ;
44811 int ecode1 = 0 ;
44812 int val2 ;
44813 int ecode2 = 0 ;
44814 int val3 ;
44815 int ecode3 = 0 ;
44816 int val4 ;
44817 int ecode4 = 0 ;
44818 int val5 ;
44819 int ecode5 = 0 ;
44820 PyObject * obj0 = 0 ;
44821 PyObject * obj1 = 0 ;
44822 PyObject * obj2 = 0 ;
44823 PyObject * obj3 = 0 ;
44824 PyObject * obj4 = 0 ;
44825 PyObject * obj5 = 0 ;
44826 char * kwnames[] = {
44827 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44828 };
44829
44830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44831 ecode1 = SWIG_AsVal_int(obj0, &val1);
44832 if (!SWIG_IsOK(ecode1)) {
44833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44834 }
44835 arg1 = static_cast< int >(val1);
44836 ecode2 = SWIG_AsVal_int(obj1, &val2);
44837 if (!SWIG_IsOK(ecode2)) {
44838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44839 }
44840 arg2 = static_cast< int >(val2);
44841 ecode3 = SWIG_AsVal_int(obj2, &val3);
44842 if (!SWIG_IsOK(ecode3)) {
44843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44844 }
44845 arg3 = static_cast< int >(val3);
44846 ecode4 = SWIG_AsVal_int(obj3, &val4);
44847 if (!SWIG_IsOK(ecode4)) {
44848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44849 }
44850 arg4 = static_cast< int >(val4);
44851 ecode5 = SWIG_AsVal_int(obj4, &val5);
44852 if (!SWIG_IsOK(ecode5)) {
44853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44854 }
44855 arg5 = static_cast< int >(val5);
44856 if (obj5) {
44857 arg6 = obj5;
44858 }
44859 {
44860 PyThreadState* __tstate = wxPyBeginAllowThreads();
44861 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44862 wxPyEndAllowThreads(__tstate);
44863 if (PyErr_Occurred()) SWIG_fail;
44864 }
44865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44866 return resultobj;
44867 fail:
44868 return NULL;
44869 }
44870
44871
44872 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44873 PyObject *resultobj = 0;
44874 wxSizer *arg1 = (wxSizer *) 0 ;
44875 int arg2 ;
44876 int arg3 ;
44877 int arg4 ;
44878 PyObject *arg5 = (PyObject *) NULL ;
44879 wxSizerItem *result = 0 ;
44880 int res1 = 0 ;
44881 int val2 ;
44882 int ecode2 = 0 ;
44883 int val3 ;
44884 int ecode3 = 0 ;
44885 int val4 ;
44886 int ecode4 = 0 ;
44887 PyObject * obj0 = 0 ;
44888 PyObject * obj1 = 0 ;
44889 PyObject * obj2 = 0 ;
44890 PyObject * obj3 = 0 ;
44891 PyObject * obj4 = 0 ;
44892 char * kwnames[] = {
44893 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44894 };
44895
44896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44897 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44898 if (!SWIG_IsOK(res1)) {
44899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44900 }
44901 ecode2 = SWIG_AsVal_int(obj1, &val2);
44902 if (!SWIG_IsOK(ecode2)) {
44903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44904 }
44905 arg2 = static_cast< int >(val2);
44906 ecode3 = SWIG_AsVal_int(obj2, &val3);
44907 if (!SWIG_IsOK(ecode3)) {
44908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44909 }
44910 arg3 = static_cast< int >(val3);
44911 ecode4 = SWIG_AsVal_int(obj3, &val4);
44912 if (!SWIG_IsOK(ecode4)) {
44913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44914 }
44915 arg4 = static_cast< int >(val4);
44916 if (obj4) {
44917 arg5 = obj4;
44918 }
44919 {
44920 PyThreadState* __tstate = wxPyBeginAllowThreads();
44921 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44922 wxPyEndAllowThreads(__tstate);
44923 if (PyErr_Occurred()) SWIG_fail;
44924 }
44925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44926 return resultobj;
44927 fail:
44928 return NULL;
44929 }
44930
44931
44932 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44933 PyObject *resultobj = 0;
44934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44935 void *argp1 = 0 ;
44936 int res1 = 0 ;
44937 PyObject *swig_obj[1] ;
44938
44939 if (!args) SWIG_fail;
44940 swig_obj[0] = args;
44941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44942 if (!SWIG_IsOK(res1)) {
44943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44944 }
44945 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44946 {
44947 PyThreadState* __tstate = wxPyBeginAllowThreads();
44948 (arg1)->DeleteWindows();
44949 wxPyEndAllowThreads(__tstate);
44950 if (PyErr_Occurred()) SWIG_fail;
44951 }
44952 resultobj = SWIG_Py_Void();
44953 return resultobj;
44954 fail:
44955 return NULL;
44956 }
44957
44958
44959 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44960 PyObject *resultobj = 0;
44961 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44962 void *argp1 = 0 ;
44963 int res1 = 0 ;
44964 PyObject *swig_obj[1] ;
44965
44966 if (!args) SWIG_fail;
44967 swig_obj[0] = args;
44968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44969 if (!SWIG_IsOK(res1)) {
44970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44971 }
44972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44973 {
44974 PyThreadState* __tstate = wxPyBeginAllowThreads();
44975 (arg1)->DetachSizer();
44976 wxPyEndAllowThreads(__tstate);
44977 if (PyErr_Occurred()) SWIG_fail;
44978 }
44979 resultobj = SWIG_Py_Void();
44980 return resultobj;
44981 fail:
44982 return NULL;
44983 }
44984
44985
44986 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44987 PyObject *resultobj = 0;
44988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44989 wxSize result;
44990 void *argp1 = 0 ;
44991 int res1 = 0 ;
44992 PyObject *swig_obj[1] ;
44993
44994 if (!args) SWIG_fail;
44995 swig_obj[0] = args;
44996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44997 if (!SWIG_IsOK(res1)) {
44998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44999 }
45000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45001 {
45002 PyThreadState* __tstate = wxPyBeginAllowThreads();
45003 result = (arg1)->GetSize();
45004 wxPyEndAllowThreads(__tstate);
45005 if (PyErr_Occurred()) SWIG_fail;
45006 }
45007 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45008 return resultobj;
45009 fail:
45010 return NULL;
45011 }
45012
45013
45014 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45015 PyObject *resultobj = 0;
45016 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45017 wxSize result;
45018 void *argp1 = 0 ;
45019 int res1 = 0 ;
45020 PyObject *swig_obj[1] ;
45021
45022 if (!args) SWIG_fail;
45023 swig_obj[0] = args;
45024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45025 if (!SWIG_IsOK(res1)) {
45026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45027 }
45028 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 result = (arg1)->CalcMin();
45032 wxPyEndAllowThreads(__tstate);
45033 if (PyErr_Occurred()) SWIG_fail;
45034 }
45035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45036 return resultobj;
45037 fail:
45038 return NULL;
45039 }
45040
45041
45042 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45043 PyObject *resultobj = 0;
45044 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45045 wxPoint *arg2 = 0 ;
45046 wxSize *arg3 = 0 ;
45047 void *argp1 = 0 ;
45048 int res1 = 0 ;
45049 wxPoint temp2 ;
45050 wxSize temp3 ;
45051 PyObject * obj0 = 0 ;
45052 PyObject * obj1 = 0 ;
45053 PyObject * obj2 = 0 ;
45054 char * kwnames[] = {
45055 (char *) "self",(char *) "pos",(char *) "size", NULL
45056 };
45057
45058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45060 if (!SWIG_IsOK(res1)) {
45061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45062 }
45063 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45064 {
45065 arg2 = &temp2;
45066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45067 }
45068 {
45069 arg3 = &temp3;
45070 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45071 }
45072 {
45073 PyThreadState* __tstate = wxPyBeginAllowThreads();
45074 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45075 wxPyEndAllowThreads(__tstate);
45076 if (PyErr_Occurred()) SWIG_fail;
45077 }
45078 resultobj = SWIG_Py_Void();
45079 return resultobj;
45080 fail:
45081 return NULL;
45082 }
45083
45084
45085 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45086 PyObject *resultobj = 0;
45087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45088 wxSize result;
45089 void *argp1 = 0 ;
45090 int res1 = 0 ;
45091 PyObject *swig_obj[1] ;
45092
45093 if (!args) SWIG_fail;
45094 swig_obj[0] = args;
45095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45096 if (!SWIG_IsOK(res1)) {
45097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45098 }
45099 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45100 {
45101 PyThreadState* __tstate = wxPyBeginAllowThreads();
45102 result = (arg1)->GetMinSize();
45103 wxPyEndAllowThreads(__tstate);
45104 if (PyErr_Occurred()) SWIG_fail;
45105 }
45106 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45107 return resultobj;
45108 fail:
45109 return NULL;
45110 }
45111
45112
45113 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45114 PyObject *resultobj = 0;
45115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45116 wxSize result;
45117 void *argp1 = 0 ;
45118 int res1 = 0 ;
45119 PyObject *swig_obj[1] ;
45120
45121 if (!args) SWIG_fail;
45122 swig_obj[0] = args;
45123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45124 if (!SWIG_IsOK(res1)) {
45125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45126 }
45127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45128 {
45129 PyThreadState* __tstate = wxPyBeginAllowThreads();
45130 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45142 PyObject *resultobj = 0;
45143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45144 int arg2 ;
45145 int arg3 ;
45146 void *argp1 = 0 ;
45147 int res1 = 0 ;
45148 int val2 ;
45149 int ecode2 = 0 ;
45150 int val3 ;
45151 int ecode3 = 0 ;
45152 PyObject * obj0 = 0 ;
45153 PyObject * obj1 = 0 ;
45154 PyObject * obj2 = 0 ;
45155 char * kwnames[] = {
45156 (char *) "self",(char *) "x",(char *) "y", NULL
45157 };
45158
45159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45161 if (!SWIG_IsOK(res1)) {
45162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45163 }
45164 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45165 ecode2 = SWIG_AsVal_int(obj1, &val2);
45166 if (!SWIG_IsOK(ecode2)) {
45167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45168 }
45169 arg2 = static_cast< int >(val2);
45170 ecode3 = SWIG_AsVal_int(obj2, &val3);
45171 if (!SWIG_IsOK(ecode3)) {
45172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45173 }
45174 arg3 = static_cast< int >(val3);
45175 {
45176 PyThreadState* __tstate = wxPyBeginAllowThreads();
45177 (arg1)->SetInitSize(arg2,arg3);
45178 wxPyEndAllowThreads(__tstate);
45179 if (PyErr_Occurred()) SWIG_fail;
45180 }
45181 resultobj = SWIG_Py_Void();
45182 return resultobj;
45183 fail:
45184 return NULL;
45185 }
45186
45187
45188 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45189 PyObject *resultobj = 0;
45190 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45191 int arg2 ;
45192 int arg3 ;
45193 void *argp1 = 0 ;
45194 int res1 = 0 ;
45195 int val2 ;
45196 int ecode2 = 0 ;
45197 int val3 ;
45198 int ecode3 = 0 ;
45199 PyObject * obj0 = 0 ;
45200 PyObject * obj1 = 0 ;
45201 PyObject * obj2 = 0 ;
45202 char * kwnames[] = {
45203 (char *) "self",(char *) "width",(char *) "height", NULL
45204 };
45205
45206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45208 if (!SWIG_IsOK(res1)) {
45209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45210 }
45211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45212 ecode2 = SWIG_AsVal_int(obj1, &val2);
45213 if (!SWIG_IsOK(ecode2)) {
45214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45215 }
45216 arg2 = static_cast< int >(val2);
45217 ecode3 = SWIG_AsVal_int(obj2, &val3);
45218 if (!SWIG_IsOK(ecode3)) {
45219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45220 }
45221 arg3 = static_cast< int >(val3);
45222 {
45223 PyThreadState* __tstate = wxPyBeginAllowThreads();
45224 (arg1)->SetRatio(arg2,arg3);
45225 wxPyEndAllowThreads(__tstate);
45226 if (PyErr_Occurred()) SWIG_fail;
45227 }
45228 resultobj = SWIG_Py_Void();
45229 return resultobj;
45230 fail:
45231 return NULL;
45232 }
45233
45234
45235 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = 0;
45237 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45238 wxSize *arg2 = 0 ;
45239 void *argp1 = 0 ;
45240 int res1 = 0 ;
45241 wxSize temp2 ;
45242 PyObject * obj0 = 0 ;
45243 PyObject * obj1 = 0 ;
45244 char * kwnames[] = {
45245 (char *) "self",(char *) "size", NULL
45246 };
45247
45248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45250 if (!SWIG_IsOK(res1)) {
45251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45252 }
45253 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45254 {
45255 arg2 = &temp2;
45256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45257 }
45258 {
45259 PyThreadState* __tstate = wxPyBeginAllowThreads();
45260 (arg1)->SetRatio((wxSize const &)*arg2);
45261 wxPyEndAllowThreads(__tstate);
45262 if (PyErr_Occurred()) SWIG_fail;
45263 }
45264 resultobj = SWIG_Py_Void();
45265 return resultobj;
45266 fail:
45267 return NULL;
45268 }
45269
45270
45271 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45272 PyObject *resultobj = 0;
45273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45274 float arg2 ;
45275 void *argp1 = 0 ;
45276 int res1 = 0 ;
45277 float val2 ;
45278 int ecode2 = 0 ;
45279 PyObject * obj0 = 0 ;
45280 PyObject * obj1 = 0 ;
45281 char * kwnames[] = {
45282 (char *) "self",(char *) "ratio", NULL
45283 };
45284
45285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45287 if (!SWIG_IsOK(res1)) {
45288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45289 }
45290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45291 ecode2 = SWIG_AsVal_float(obj1, &val2);
45292 if (!SWIG_IsOK(ecode2)) {
45293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45294 }
45295 arg2 = static_cast< float >(val2);
45296 {
45297 PyThreadState* __tstate = wxPyBeginAllowThreads();
45298 (arg1)->SetRatio(arg2);
45299 wxPyEndAllowThreads(__tstate);
45300 if (PyErr_Occurred()) SWIG_fail;
45301 }
45302 resultobj = SWIG_Py_Void();
45303 return resultobj;
45304 fail:
45305 return NULL;
45306 }
45307
45308
45309 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45310 PyObject *resultobj = 0;
45311 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45312 float result;
45313 void *argp1 = 0 ;
45314 int res1 = 0 ;
45315 PyObject *swig_obj[1] ;
45316
45317 if (!args) SWIG_fail;
45318 swig_obj[0] = args;
45319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45320 if (!SWIG_IsOK(res1)) {
45321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45322 }
45323 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45324 {
45325 PyThreadState* __tstate = wxPyBeginAllowThreads();
45326 result = (float)(arg1)->GetRatio();
45327 wxPyEndAllowThreads(__tstate);
45328 if (PyErr_Occurred()) SWIG_fail;
45329 }
45330 resultobj = SWIG_From_float(static_cast< float >(result));
45331 return resultobj;
45332 fail:
45333 return NULL;
45334 }
45335
45336
45337 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45338 PyObject *resultobj = 0;
45339 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45340 wxRect result;
45341 void *argp1 = 0 ;
45342 int res1 = 0 ;
45343 PyObject *swig_obj[1] ;
45344
45345 if (!args) SWIG_fail;
45346 swig_obj[0] = args;
45347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45348 if (!SWIG_IsOK(res1)) {
45349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45350 }
45351 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45352 {
45353 PyThreadState* __tstate = wxPyBeginAllowThreads();
45354 result = (arg1)->GetRect();
45355 wxPyEndAllowThreads(__tstate);
45356 if (PyErr_Occurred()) SWIG_fail;
45357 }
45358 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45359 return resultobj;
45360 fail:
45361 return NULL;
45362 }
45363
45364
45365 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45366 PyObject *resultobj = 0;
45367 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45368 bool result;
45369 void *argp1 = 0 ;
45370 int res1 = 0 ;
45371 PyObject *swig_obj[1] ;
45372
45373 if (!args) SWIG_fail;
45374 swig_obj[0] = args;
45375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45376 if (!SWIG_IsOK(res1)) {
45377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45378 }
45379 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45380 {
45381 PyThreadState* __tstate = wxPyBeginAllowThreads();
45382 result = (bool)(arg1)->IsWindow();
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 {
45387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45388 }
45389 return resultobj;
45390 fail:
45391 return NULL;
45392 }
45393
45394
45395 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45396 PyObject *resultobj = 0;
45397 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45398 bool result;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 PyObject *swig_obj[1] ;
45402
45403 if (!args) SWIG_fail;
45404 swig_obj[0] = args;
45405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45406 if (!SWIG_IsOK(res1)) {
45407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45408 }
45409 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = (bool)(arg1)->IsSizer();
45413 wxPyEndAllowThreads(__tstate);
45414 if (PyErr_Occurred()) SWIG_fail;
45415 }
45416 {
45417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45418 }
45419 return resultobj;
45420 fail:
45421 return NULL;
45422 }
45423
45424
45425 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45426 PyObject *resultobj = 0;
45427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45428 bool result;
45429 void *argp1 = 0 ;
45430 int res1 = 0 ;
45431 PyObject *swig_obj[1] ;
45432
45433 if (!args) SWIG_fail;
45434 swig_obj[0] = args;
45435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45436 if (!SWIG_IsOK(res1)) {
45437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45438 }
45439 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45440 {
45441 PyThreadState* __tstate = wxPyBeginAllowThreads();
45442 result = (bool)(arg1)->IsSpacer();
45443 wxPyEndAllowThreads(__tstate);
45444 if (PyErr_Occurred()) SWIG_fail;
45445 }
45446 {
45447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45448 }
45449 return resultobj;
45450 fail:
45451 return NULL;
45452 }
45453
45454
45455 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45456 PyObject *resultobj = 0;
45457 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45458 int arg2 ;
45459 void *argp1 = 0 ;
45460 int res1 = 0 ;
45461 int val2 ;
45462 int ecode2 = 0 ;
45463 PyObject * obj0 = 0 ;
45464 PyObject * obj1 = 0 ;
45465 char * kwnames[] = {
45466 (char *) "self",(char *) "proportion", NULL
45467 };
45468
45469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45471 if (!SWIG_IsOK(res1)) {
45472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45473 }
45474 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45475 ecode2 = SWIG_AsVal_int(obj1, &val2);
45476 if (!SWIG_IsOK(ecode2)) {
45477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45478 }
45479 arg2 = static_cast< int >(val2);
45480 {
45481 PyThreadState* __tstate = wxPyBeginAllowThreads();
45482 (arg1)->SetProportion(arg2);
45483 wxPyEndAllowThreads(__tstate);
45484 if (PyErr_Occurred()) SWIG_fail;
45485 }
45486 resultobj = SWIG_Py_Void();
45487 return resultobj;
45488 fail:
45489 return NULL;
45490 }
45491
45492
45493 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45494 PyObject *resultobj = 0;
45495 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45496 int result;
45497 void *argp1 = 0 ;
45498 int res1 = 0 ;
45499 PyObject *swig_obj[1] ;
45500
45501 if (!args) SWIG_fail;
45502 swig_obj[0] = args;
45503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45504 if (!SWIG_IsOK(res1)) {
45505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45506 }
45507 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45508 {
45509 PyThreadState* __tstate = wxPyBeginAllowThreads();
45510 result = (int)(arg1)->GetProportion();
45511 wxPyEndAllowThreads(__tstate);
45512 if (PyErr_Occurred()) SWIG_fail;
45513 }
45514 resultobj = SWIG_From_int(static_cast< int >(result));
45515 return resultobj;
45516 fail:
45517 return NULL;
45518 }
45519
45520
45521 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj = 0;
45523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45524 int arg2 ;
45525 void *argp1 = 0 ;
45526 int res1 = 0 ;
45527 int val2 ;
45528 int ecode2 = 0 ;
45529 PyObject * obj0 = 0 ;
45530 PyObject * obj1 = 0 ;
45531 char * kwnames[] = {
45532 (char *) "self",(char *) "flag", NULL
45533 };
45534
45535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45537 if (!SWIG_IsOK(res1)) {
45538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45539 }
45540 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45541 ecode2 = SWIG_AsVal_int(obj1, &val2);
45542 if (!SWIG_IsOK(ecode2)) {
45543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45544 }
45545 arg2 = static_cast< int >(val2);
45546 {
45547 PyThreadState* __tstate = wxPyBeginAllowThreads();
45548 (arg1)->SetFlag(arg2);
45549 wxPyEndAllowThreads(__tstate);
45550 if (PyErr_Occurred()) SWIG_fail;
45551 }
45552 resultobj = SWIG_Py_Void();
45553 return resultobj;
45554 fail:
45555 return NULL;
45556 }
45557
45558
45559 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45560 PyObject *resultobj = 0;
45561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45562 int result;
45563 void *argp1 = 0 ;
45564 int res1 = 0 ;
45565 PyObject *swig_obj[1] ;
45566
45567 if (!args) SWIG_fail;
45568 swig_obj[0] = args;
45569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45570 if (!SWIG_IsOK(res1)) {
45571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45572 }
45573 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45574 {
45575 PyThreadState* __tstate = wxPyBeginAllowThreads();
45576 result = (int)(arg1)->GetFlag();
45577 wxPyEndAllowThreads(__tstate);
45578 if (PyErr_Occurred()) SWIG_fail;
45579 }
45580 resultobj = SWIG_From_int(static_cast< int >(result));
45581 return resultobj;
45582 fail:
45583 return NULL;
45584 }
45585
45586
45587 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45588 PyObject *resultobj = 0;
45589 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45590 int arg2 ;
45591 void *argp1 = 0 ;
45592 int res1 = 0 ;
45593 int val2 ;
45594 int ecode2 = 0 ;
45595 PyObject * obj0 = 0 ;
45596 PyObject * obj1 = 0 ;
45597 char * kwnames[] = {
45598 (char *) "self",(char *) "border", NULL
45599 };
45600
45601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45603 if (!SWIG_IsOK(res1)) {
45604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45605 }
45606 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45607 ecode2 = SWIG_AsVal_int(obj1, &val2);
45608 if (!SWIG_IsOK(ecode2)) {
45609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45610 }
45611 arg2 = static_cast< int >(val2);
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 (arg1)->SetBorder(arg2);
45615 wxPyEndAllowThreads(__tstate);
45616 if (PyErr_Occurred()) SWIG_fail;
45617 }
45618 resultobj = SWIG_Py_Void();
45619 return resultobj;
45620 fail:
45621 return NULL;
45622 }
45623
45624
45625 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45626 PyObject *resultobj = 0;
45627 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45628 int result;
45629 void *argp1 = 0 ;
45630 int res1 = 0 ;
45631 PyObject *swig_obj[1] ;
45632
45633 if (!args) SWIG_fail;
45634 swig_obj[0] = args;
45635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45636 if (!SWIG_IsOK(res1)) {
45637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45638 }
45639 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45640 {
45641 PyThreadState* __tstate = wxPyBeginAllowThreads();
45642 result = (int)(arg1)->GetBorder();
45643 wxPyEndAllowThreads(__tstate);
45644 if (PyErr_Occurred()) SWIG_fail;
45645 }
45646 resultobj = SWIG_From_int(static_cast< int >(result));
45647 return resultobj;
45648 fail:
45649 return NULL;
45650 }
45651
45652
45653 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45654 PyObject *resultobj = 0;
45655 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45656 wxWindow *result = 0 ;
45657 void *argp1 = 0 ;
45658 int res1 = 0 ;
45659 PyObject *swig_obj[1] ;
45660
45661 if (!args) SWIG_fail;
45662 swig_obj[0] = args;
45663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45664 if (!SWIG_IsOK(res1)) {
45665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45666 }
45667 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45668 {
45669 PyThreadState* __tstate = wxPyBeginAllowThreads();
45670 result = (wxWindow *)(arg1)->GetWindow();
45671 wxPyEndAllowThreads(__tstate);
45672 if (PyErr_Occurred()) SWIG_fail;
45673 }
45674 {
45675 resultobj = wxPyMake_wxObject(result, 0);
45676 }
45677 return resultobj;
45678 fail:
45679 return NULL;
45680 }
45681
45682
45683 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45684 PyObject *resultobj = 0;
45685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45686 wxWindow *arg2 = (wxWindow *) 0 ;
45687 void *argp1 = 0 ;
45688 int res1 = 0 ;
45689 void *argp2 = 0 ;
45690 int res2 = 0 ;
45691 PyObject * obj0 = 0 ;
45692 PyObject * obj1 = 0 ;
45693 char * kwnames[] = {
45694 (char *) "self",(char *) "window", NULL
45695 };
45696
45697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45699 if (!SWIG_IsOK(res1)) {
45700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45701 }
45702 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45703 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45704 if (!SWIG_IsOK(res2)) {
45705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45706 }
45707 arg2 = reinterpret_cast< wxWindow * >(argp2);
45708 {
45709 PyThreadState* __tstate = wxPyBeginAllowThreads();
45710 (arg1)->SetWindow(arg2);
45711 wxPyEndAllowThreads(__tstate);
45712 if (PyErr_Occurred()) SWIG_fail;
45713 }
45714 resultobj = SWIG_Py_Void();
45715 return resultobj;
45716 fail:
45717 return NULL;
45718 }
45719
45720
45721 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45722 PyObject *resultobj = 0;
45723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45724 wxSizer *result = 0 ;
45725 void *argp1 = 0 ;
45726 int res1 = 0 ;
45727 PyObject *swig_obj[1] ;
45728
45729 if (!args) SWIG_fail;
45730 swig_obj[0] = args;
45731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45732 if (!SWIG_IsOK(res1)) {
45733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45734 }
45735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45736 {
45737 PyThreadState* __tstate = wxPyBeginAllowThreads();
45738 result = (wxSizer *)(arg1)->GetSizer();
45739 wxPyEndAllowThreads(__tstate);
45740 if (PyErr_Occurred()) SWIG_fail;
45741 }
45742 {
45743 resultobj = wxPyMake_wxObject(result, (bool)0);
45744 }
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45752 PyObject *resultobj = 0;
45753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45754 wxSizer *arg2 = (wxSizer *) 0 ;
45755 void *argp1 = 0 ;
45756 int res1 = 0 ;
45757 int res2 = 0 ;
45758 PyObject * obj0 = 0 ;
45759 PyObject * obj1 = 0 ;
45760 char * kwnames[] = {
45761 (char *) "self",(char *) "sizer", NULL
45762 };
45763
45764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45766 if (!SWIG_IsOK(res1)) {
45767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45768 }
45769 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45770 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45771 if (!SWIG_IsOK(res2)) {
45772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45773 }
45774 {
45775 PyThreadState* __tstate = wxPyBeginAllowThreads();
45776 (arg1)->SetSizer(arg2);
45777 wxPyEndAllowThreads(__tstate);
45778 if (PyErr_Occurred()) SWIG_fail;
45779 }
45780 resultobj = SWIG_Py_Void();
45781 return resultobj;
45782 fail:
45783 return NULL;
45784 }
45785
45786
45787 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45788 PyObject *resultobj = 0;
45789 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45790 wxSize *result = 0 ;
45791 void *argp1 = 0 ;
45792 int res1 = 0 ;
45793 PyObject *swig_obj[1] ;
45794
45795 if (!args) SWIG_fail;
45796 swig_obj[0] = args;
45797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45800 }
45801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 {
45805 wxSize const &_result_ref = (arg1)->GetSpacer();
45806 result = (wxSize *) &_result_ref;
45807 }
45808 wxPyEndAllowThreads(__tstate);
45809 if (PyErr_Occurred()) SWIG_fail;
45810 }
45811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45812 return resultobj;
45813 fail:
45814 return NULL;
45815 }
45816
45817
45818 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45819 PyObject *resultobj = 0;
45820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45821 wxSize *arg2 = 0 ;
45822 void *argp1 = 0 ;
45823 int res1 = 0 ;
45824 wxSize temp2 ;
45825 PyObject * obj0 = 0 ;
45826 PyObject * obj1 = 0 ;
45827 char * kwnames[] = {
45828 (char *) "self",(char *) "size", NULL
45829 };
45830
45831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45833 if (!SWIG_IsOK(res1)) {
45834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45835 }
45836 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45837 {
45838 arg2 = &temp2;
45839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45840 }
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 (arg1)->SetSpacer((wxSize const &)*arg2);
45844 wxPyEndAllowThreads(__tstate);
45845 if (PyErr_Occurred()) SWIG_fail;
45846 }
45847 resultobj = SWIG_Py_Void();
45848 return resultobj;
45849 fail:
45850 return NULL;
45851 }
45852
45853
45854 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45855 PyObject *resultobj = 0;
45856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45857 bool arg2 ;
45858 void *argp1 = 0 ;
45859 int res1 = 0 ;
45860 bool val2 ;
45861 int ecode2 = 0 ;
45862 PyObject * obj0 = 0 ;
45863 PyObject * obj1 = 0 ;
45864 char * kwnames[] = {
45865 (char *) "self",(char *) "show", NULL
45866 };
45867
45868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45870 if (!SWIG_IsOK(res1)) {
45871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45872 }
45873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45875 if (!SWIG_IsOK(ecode2)) {
45876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45877 }
45878 arg2 = static_cast< bool >(val2);
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 (arg1)->Show(arg2);
45882 wxPyEndAllowThreads(__tstate);
45883 if (PyErr_Occurred()) SWIG_fail;
45884 }
45885 resultobj = SWIG_Py_Void();
45886 return resultobj;
45887 fail:
45888 return NULL;
45889 }
45890
45891
45892 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45893 PyObject *resultobj = 0;
45894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45895 bool result;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 PyObject *swig_obj[1] ;
45899
45900 if (!args) SWIG_fail;
45901 swig_obj[0] = args;
45902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45903 if (!SWIG_IsOK(res1)) {
45904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45905 }
45906 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 result = (bool)(arg1)->IsShown();
45910 wxPyEndAllowThreads(__tstate);
45911 if (PyErr_Occurred()) SWIG_fail;
45912 }
45913 {
45914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45915 }
45916 return resultobj;
45917 fail:
45918 return NULL;
45919 }
45920
45921
45922 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45923 PyObject *resultobj = 0;
45924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45925 wxPoint result;
45926 void *argp1 = 0 ;
45927 int res1 = 0 ;
45928 PyObject *swig_obj[1] ;
45929
45930 if (!args) SWIG_fail;
45931 swig_obj[0] = args;
45932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45933 if (!SWIG_IsOK(res1)) {
45934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45935 }
45936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45937 {
45938 PyThreadState* __tstate = wxPyBeginAllowThreads();
45939 result = (arg1)->GetPosition();
45940 wxPyEndAllowThreads(__tstate);
45941 if (PyErr_Occurred()) SWIG_fail;
45942 }
45943 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45944 return resultobj;
45945 fail:
45946 return NULL;
45947 }
45948
45949
45950 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45951 PyObject *resultobj = 0;
45952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45953 PyObject *result = 0 ;
45954 void *argp1 = 0 ;
45955 int res1 = 0 ;
45956 PyObject *swig_obj[1] ;
45957
45958 if (!args) SWIG_fail;
45959 swig_obj[0] = args;
45960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45961 if (!SWIG_IsOK(res1)) {
45962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45963 }
45964 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45965 {
45966 PyThreadState* __tstate = wxPyBeginAllowThreads();
45967 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45968 wxPyEndAllowThreads(__tstate);
45969 if (PyErr_Occurred()) SWIG_fail;
45970 }
45971 resultobj = result;
45972 return resultobj;
45973 fail:
45974 return NULL;
45975 }
45976
45977
45978 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45979 PyObject *resultobj = 0;
45980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45981 PyObject *arg2 = (PyObject *) 0 ;
45982 void *argp1 = 0 ;
45983 int res1 = 0 ;
45984 PyObject * obj0 = 0 ;
45985 PyObject * obj1 = 0 ;
45986 char * kwnames[] = {
45987 (char *) "self",(char *) "userData", NULL
45988 };
45989
45990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45992 if (!SWIG_IsOK(res1)) {
45993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45994 }
45995 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45996 arg2 = obj1;
45997 {
45998 PyThreadState* __tstate = wxPyBeginAllowThreads();
45999 wxSizerItem_SetUserData(arg1,arg2);
46000 wxPyEndAllowThreads(__tstate);
46001 if (PyErr_Occurred()) SWIG_fail;
46002 }
46003 resultobj = SWIG_Py_Void();
46004 return resultobj;
46005 fail:
46006 return NULL;
46007 }
46008
46009
46010 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46011 PyObject *obj;
46012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46013 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46014 return SWIG_Py_Void();
46015 }
46016
46017 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46018 return SWIG_Python_InitShadowInstance(args);
46019 }
46020
46021 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46022 PyObject *resultobj = 0;
46023 wxSizer *arg1 = (wxSizer *) 0 ;
46024 void *argp1 = 0 ;
46025 int res1 = 0 ;
46026 PyObject *swig_obj[1] ;
46027
46028 if (!args) SWIG_fail;
46029 swig_obj[0] = args;
46030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46031 if (!SWIG_IsOK(res1)) {
46032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46033 }
46034 arg1 = reinterpret_cast< wxSizer * >(argp1);
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 delete arg1;
46038
46039 wxPyEndAllowThreads(__tstate);
46040 if (PyErr_Occurred()) SWIG_fail;
46041 }
46042 resultobj = SWIG_Py_Void();
46043 return resultobj;
46044 fail:
46045 return NULL;
46046 }
46047
46048
46049 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46050 PyObject *resultobj = 0;
46051 wxSizer *arg1 = (wxSizer *) 0 ;
46052 PyObject *arg2 = (PyObject *) 0 ;
46053 void *argp1 = 0 ;
46054 int res1 = 0 ;
46055 PyObject * obj0 = 0 ;
46056 PyObject * obj1 = 0 ;
46057 char * kwnames[] = {
46058 (char *) "self",(char *) "_self", NULL
46059 };
46060
46061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46063 if (!SWIG_IsOK(res1)) {
46064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46065 }
46066 arg1 = reinterpret_cast< wxSizer * >(argp1);
46067 arg2 = obj1;
46068 {
46069 PyThreadState* __tstate = wxPyBeginAllowThreads();
46070 wxSizer__setOORInfo(arg1,arg2);
46071 wxPyEndAllowThreads(__tstate);
46072 if (PyErr_Occurred()) SWIG_fail;
46073 }
46074 resultobj = SWIG_Py_Void();
46075 return resultobj;
46076 fail:
46077 return NULL;
46078 }
46079
46080
46081 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46082 PyObject *resultobj = 0;
46083 wxSizer *arg1 = (wxSizer *) 0 ;
46084 PyObject *arg2 = (PyObject *) 0 ;
46085 int arg3 = (int) 0 ;
46086 int arg4 = (int) 0 ;
46087 int arg5 = (int) 0 ;
46088 PyObject *arg6 = (PyObject *) NULL ;
46089 wxSizerItem *result = 0 ;
46090 void *argp1 = 0 ;
46091 int res1 = 0 ;
46092 int val3 ;
46093 int ecode3 = 0 ;
46094 int val4 ;
46095 int ecode4 = 0 ;
46096 int val5 ;
46097 int ecode5 = 0 ;
46098 PyObject * obj0 = 0 ;
46099 PyObject * obj1 = 0 ;
46100 PyObject * obj2 = 0 ;
46101 PyObject * obj3 = 0 ;
46102 PyObject * obj4 = 0 ;
46103 PyObject * obj5 = 0 ;
46104 char * kwnames[] = {
46105 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46106 };
46107
46108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46110 if (!SWIG_IsOK(res1)) {
46111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46112 }
46113 arg1 = reinterpret_cast< wxSizer * >(argp1);
46114 arg2 = obj1;
46115 if (obj2) {
46116 ecode3 = SWIG_AsVal_int(obj2, &val3);
46117 if (!SWIG_IsOK(ecode3)) {
46118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46119 }
46120 arg3 = static_cast< int >(val3);
46121 }
46122 if (obj3) {
46123 ecode4 = SWIG_AsVal_int(obj3, &val4);
46124 if (!SWIG_IsOK(ecode4)) {
46125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46126 }
46127 arg4 = static_cast< int >(val4);
46128 }
46129 if (obj4) {
46130 ecode5 = SWIG_AsVal_int(obj4, &val5);
46131 if (!SWIG_IsOK(ecode5)) {
46132 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46133 }
46134 arg5 = static_cast< int >(val5);
46135 }
46136 if (obj5) {
46137 arg6 = obj5;
46138 }
46139 {
46140 PyThreadState* __tstate = wxPyBeginAllowThreads();
46141 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46142 wxPyEndAllowThreads(__tstate);
46143 if (PyErr_Occurred()) SWIG_fail;
46144 }
46145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46146 return resultobj;
46147 fail:
46148 return NULL;
46149 }
46150
46151
46152 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46153 PyObject *resultobj = 0;
46154 wxSizer *arg1 = (wxSizer *) 0 ;
46155 int arg2 ;
46156 PyObject *arg3 = (PyObject *) 0 ;
46157 int arg4 = (int) 0 ;
46158 int arg5 = (int) 0 ;
46159 int arg6 = (int) 0 ;
46160 PyObject *arg7 = (PyObject *) NULL ;
46161 wxSizerItem *result = 0 ;
46162 void *argp1 = 0 ;
46163 int res1 = 0 ;
46164 int val2 ;
46165 int ecode2 = 0 ;
46166 int val4 ;
46167 int ecode4 = 0 ;
46168 int val5 ;
46169 int ecode5 = 0 ;
46170 int val6 ;
46171 int ecode6 = 0 ;
46172 PyObject * obj0 = 0 ;
46173 PyObject * obj1 = 0 ;
46174 PyObject * obj2 = 0 ;
46175 PyObject * obj3 = 0 ;
46176 PyObject * obj4 = 0 ;
46177 PyObject * obj5 = 0 ;
46178 PyObject * obj6 = 0 ;
46179 char * kwnames[] = {
46180 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46181 };
46182
46183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46185 if (!SWIG_IsOK(res1)) {
46186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46187 }
46188 arg1 = reinterpret_cast< wxSizer * >(argp1);
46189 ecode2 = SWIG_AsVal_int(obj1, &val2);
46190 if (!SWIG_IsOK(ecode2)) {
46191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46192 }
46193 arg2 = static_cast< int >(val2);
46194 arg3 = obj2;
46195 if (obj3) {
46196 ecode4 = SWIG_AsVal_int(obj3, &val4);
46197 if (!SWIG_IsOK(ecode4)) {
46198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46199 }
46200 arg4 = static_cast< int >(val4);
46201 }
46202 if (obj4) {
46203 ecode5 = SWIG_AsVal_int(obj4, &val5);
46204 if (!SWIG_IsOK(ecode5)) {
46205 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46206 }
46207 arg5 = static_cast< int >(val5);
46208 }
46209 if (obj5) {
46210 ecode6 = SWIG_AsVal_int(obj5, &val6);
46211 if (!SWIG_IsOK(ecode6)) {
46212 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46213 }
46214 arg6 = static_cast< int >(val6);
46215 }
46216 if (obj6) {
46217 arg7 = obj6;
46218 }
46219 {
46220 PyThreadState* __tstate = wxPyBeginAllowThreads();
46221 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46222 wxPyEndAllowThreads(__tstate);
46223 if (PyErr_Occurred()) SWIG_fail;
46224 }
46225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46226 return resultobj;
46227 fail:
46228 return NULL;
46229 }
46230
46231
46232 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46233 PyObject *resultobj = 0;
46234 wxSizer *arg1 = (wxSizer *) 0 ;
46235 PyObject *arg2 = (PyObject *) 0 ;
46236 int arg3 = (int) 0 ;
46237 int arg4 = (int) 0 ;
46238 int arg5 = (int) 0 ;
46239 PyObject *arg6 = (PyObject *) NULL ;
46240 wxSizerItem *result = 0 ;
46241 void *argp1 = 0 ;
46242 int res1 = 0 ;
46243 int val3 ;
46244 int ecode3 = 0 ;
46245 int val4 ;
46246 int ecode4 = 0 ;
46247 int val5 ;
46248 int ecode5 = 0 ;
46249 PyObject * obj0 = 0 ;
46250 PyObject * obj1 = 0 ;
46251 PyObject * obj2 = 0 ;
46252 PyObject * obj3 = 0 ;
46253 PyObject * obj4 = 0 ;
46254 PyObject * obj5 = 0 ;
46255 char * kwnames[] = {
46256 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46257 };
46258
46259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46261 if (!SWIG_IsOK(res1)) {
46262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46263 }
46264 arg1 = reinterpret_cast< wxSizer * >(argp1);
46265 arg2 = obj1;
46266 if (obj2) {
46267 ecode3 = SWIG_AsVal_int(obj2, &val3);
46268 if (!SWIG_IsOK(ecode3)) {
46269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46270 }
46271 arg3 = static_cast< int >(val3);
46272 }
46273 if (obj3) {
46274 ecode4 = SWIG_AsVal_int(obj3, &val4);
46275 if (!SWIG_IsOK(ecode4)) {
46276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46277 }
46278 arg4 = static_cast< int >(val4);
46279 }
46280 if (obj4) {
46281 ecode5 = SWIG_AsVal_int(obj4, &val5);
46282 if (!SWIG_IsOK(ecode5)) {
46283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46284 }
46285 arg5 = static_cast< int >(val5);
46286 }
46287 if (obj5) {
46288 arg6 = obj5;
46289 }
46290 {
46291 PyThreadState* __tstate = wxPyBeginAllowThreads();
46292 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46293 wxPyEndAllowThreads(__tstate);
46294 if (PyErr_Occurred()) SWIG_fail;
46295 }
46296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46297 return resultobj;
46298 fail:
46299 return NULL;
46300 }
46301
46302
46303 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46304 PyObject *resultobj = 0;
46305 wxSizer *arg1 = (wxSizer *) 0 ;
46306 PyObject *arg2 = (PyObject *) 0 ;
46307 bool result;
46308 void *argp1 = 0 ;
46309 int res1 = 0 ;
46310 PyObject * obj0 = 0 ;
46311 PyObject * obj1 = 0 ;
46312 char * kwnames[] = {
46313 (char *) "self",(char *) "item", NULL
46314 };
46315
46316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46320 }
46321 arg1 = reinterpret_cast< wxSizer * >(argp1);
46322 arg2 = obj1;
46323 {
46324 PyThreadState* __tstate = wxPyBeginAllowThreads();
46325 result = (bool)wxSizer_Remove(arg1,arg2);
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 {
46330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46331 }
46332 return resultobj;
46333 fail:
46334 return NULL;
46335 }
46336
46337
46338 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46339 PyObject *resultobj = 0;
46340 wxSizer *arg1 = (wxSizer *) 0 ;
46341 PyObject *arg2 = (PyObject *) 0 ;
46342 bool result;
46343 void *argp1 = 0 ;
46344 int res1 = 0 ;
46345 PyObject * obj0 = 0 ;
46346 PyObject * obj1 = 0 ;
46347 char * kwnames[] = {
46348 (char *) "self",(char *) "item", NULL
46349 };
46350
46351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46353 if (!SWIG_IsOK(res1)) {
46354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46355 }
46356 arg1 = reinterpret_cast< wxSizer * >(argp1);
46357 arg2 = obj1;
46358 {
46359 PyThreadState* __tstate = wxPyBeginAllowThreads();
46360 result = (bool)wxSizer_Detach(arg1,arg2);
46361 wxPyEndAllowThreads(__tstate);
46362 if (PyErr_Occurred()) SWIG_fail;
46363 }
46364 {
46365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46366 }
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46374 PyObject *resultobj = 0;
46375 wxSizer *arg1 = (wxSizer *) 0 ;
46376 PyObject *arg2 = (PyObject *) 0 ;
46377 wxSizerItem *result = 0 ;
46378 void *argp1 = 0 ;
46379 int res1 = 0 ;
46380 PyObject * obj0 = 0 ;
46381 PyObject * obj1 = 0 ;
46382 char * kwnames[] = {
46383 (char *) "self",(char *) "item", NULL
46384 };
46385
46386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46388 if (!SWIG_IsOK(res1)) {
46389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46390 }
46391 arg1 = reinterpret_cast< wxSizer * >(argp1);
46392 arg2 = obj1;
46393 {
46394 PyThreadState* __tstate = wxPyBeginAllowThreads();
46395 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46396 wxPyEndAllowThreads(__tstate);
46397 if (PyErr_Occurred()) SWIG_fail;
46398 }
46399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46400 return resultobj;
46401 fail:
46402 return NULL;
46403 }
46404
46405
46406 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46407 PyObject *resultobj = 0;
46408 wxSizer *arg1 = (wxSizer *) 0 ;
46409 PyObject *arg2 = (PyObject *) 0 ;
46410 wxSize *arg3 = 0 ;
46411 void *argp1 = 0 ;
46412 int res1 = 0 ;
46413 wxSize temp3 ;
46414 PyObject * obj0 = 0 ;
46415 PyObject * obj1 = 0 ;
46416 PyObject * obj2 = 0 ;
46417 char * kwnames[] = {
46418 (char *) "self",(char *) "item",(char *) "size", NULL
46419 };
46420
46421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46423 if (!SWIG_IsOK(res1)) {
46424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46425 }
46426 arg1 = reinterpret_cast< wxSizer * >(argp1);
46427 arg2 = obj1;
46428 {
46429 arg3 = &temp3;
46430 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46431 }
46432 {
46433 PyThreadState* __tstate = wxPyBeginAllowThreads();
46434 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46435 wxPyEndAllowThreads(__tstate);
46436 if (PyErr_Occurred()) SWIG_fail;
46437 }
46438 resultobj = SWIG_Py_Void();
46439 return resultobj;
46440 fail:
46441 return NULL;
46442 }
46443
46444
46445 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46446 PyObject *resultobj = 0;
46447 wxSizer *arg1 = (wxSizer *) 0 ;
46448 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46449 wxSizerItem *result = 0 ;
46450 void *argp1 = 0 ;
46451 int res1 = 0 ;
46452 int res2 = 0 ;
46453 PyObject * obj0 = 0 ;
46454 PyObject * obj1 = 0 ;
46455 char * kwnames[] = {
46456 (char *) "self",(char *) "item", NULL
46457 };
46458
46459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46461 if (!SWIG_IsOK(res1)) {
46462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46463 }
46464 arg1 = reinterpret_cast< wxSizer * >(argp1);
46465 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46466 if (!SWIG_IsOK(res2)) {
46467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46468 }
46469 {
46470 PyThreadState* __tstate = wxPyBeginAllowThreads();
46471 result = (wxSizerItem *)(arg1)->Add(arg2);
46472 wxPyEndAllowThreads(__tstate);
46473 if (PyErr_Occurred()) SWIG_fail;
46474 }
46475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46476 return resultobj;
46477 fail:
46478 return NULL;
46479 }
46480
46481
46482 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46483 PyObject *resultobj = 0;
46484 wxSizer *arg1 = (wxSizer *) 0 ;
46485 size_t arg2 ;
46486 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46487 wxSizerItem *result = 0 ;
46488 void *argp1 = 0 ;
46489 int res1 = 0 ;
46490 size_t val2 ;
46491 int ecode2 = 0 ;
46492 int res3 = 0 ;
46493 PyObject * obj0 = 0 ;
46494 PyObject * obj1 = 0 ;
46495 PyObject * obj2 = 0 ;
46496 char * kwnames[] = {
46497 (char *) "self",(char *) "index",(char *) "item", NULL
46498 };
46499
46500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46502 if (!SWIG_IsOK(res1)) {
46503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46504 }
46505 arg1 = reinterpret_cast< wxSizer * >(argp1);
46506 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46507 if (!SWIG_IsOK(ecode2)) {
46508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46509 }
46510 arg2 = static_cast< size_t >(val2);
46511 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46512 if (!SWIG_IsOK(res3)) {
46513 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46514 }
46515 {
46516 PyThreadState* __tstate = wxPyBeginAllowThreads();
46517 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46518 wxPyEndAllowThreads(__tstate);
46519 if (PyErr_Occurred()) SWIG_fail;
46520 }
46521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46522 return resultobj;
46523 fail:
46524 return NULL;
46525 }
46526
46527
46528 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46529 PyObject *resultobj = 0;
46530 wxSizer *arg1 = (wxSizer *) 0 ;
46531 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46532 wxSizerItem *result = 0 ;
46533 void *argp1 = 0 ;
46534 int res1 = 0 ;
46535 int res2 = 0 ;
46536 PyObject * obj0 = 0 ;
46537 PyObject * obj1 = 0 ;
46538 char * kwnames[] = {
46539 (char *) "self",(char *) "item", NULL
46540 };
46541
46542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46544 if (!SWIG_IsOK(res1)) {
46545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46546 }
46547 arg1 = reinterpret_cast< wxSizer * >(argp1);
46548 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46549 if (!SWIG_IsOK(res2)) {
46550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46551 }
46552 {
46553 PyThreadState* __tstate = wxPyBeginAllowThreads();
46554 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46555 wxPyEndAllowThreads(__tstate);
46556 if (PyErr_Occurred()) SWIG_fail;
46557 }
46558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46566 PyObject *resultobj = 0;
46567 wxSizer *arg1 = (wxSizer *) 0 ;
46568 int arg2 ;
46569 int arg3 ;
46570 int arg4 ;
46571 int arg5 ;
46572 void *argp1 = 0 ;
46573 int res1 = 0 ;
46574 int val2 ;
46575 int ecode2 = 0 ;
46576 int val3 ;
46577 int ecode3 = 0 ;
46578 int val4 ;
46579 int ecode4 = 0 ;
46580 int val5 ;
46581 int ecode5 = 0 ;
46582 PyObject * obj0 = 0 ;
46583 PyObject * obj1 = 0 ;
46584 PyObject * obj2 = 0 ;
46585 PyObject * obj3 = 0 ;
46586 PyObject * obj4 = 0 ;
46587 char * kwnames[] = {
46588 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46589 };
46590
46591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46593 if (!SWIG_IsOK(res1)) {
46594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46595 }
46596 arg1 = reinterpret_cast< wxSizer * >(argp1);
46597 ecode2 = SWIG_AsVal_int(obj1, &val2);
46598 if (!SWIG_IsOK(ecode2)) {
46599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46600 }
46601 arg2 = static_cast< int >(val2);
46602 ecode3 = SWIG_AsVal_int(obj2, &val3);
46603 if (!SWIG_IsOK(ecode3)) {
46604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46605 }
46606 arg3 = static_cast< int >(val3);
46607 ecode4 = SWIG_AsVal_int(obj3, &val4);
46608 if (!SWIG_IsOK(ecode4)) {
46609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46610 }
46611 arg4 = static_cast< int >(val4);
46612 ecode5 = SWIG_AsVal_int(obj4, &val5);
46613 if (!SWIG_IsOK(ecode5)) {
46614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46615 }
46616 arg5 = static_cast< int >(val5);
46617 {
46618 PyThreadState* __tstate = wxPyBeginAllowThreads();
46619 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46620 wxPyEndAllowThreads(__tstate);
46621 if (PyErr_Occurred()) SWIG_fail;
46622 }
46623 resultobj = SWIG_Py_Void();
46624 return resultobj;
46625 fail:
46626 return NULL;
46627 }
46628
46629
46630 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46631 PyObject *resultobj = 0;
46632 wxSizer *arg1 = (wxSizer *) 0 ;
46633 wxSize *arg2 = 0 ;
46634 void *argp1 = 0 ;
46635 int res1 = 0 ;
46636 wxSize temp2 ;
46637 PyObject * obj0 = 0 ;
46638 PyObject * obj1 = 0 ;
46639 char * kwnames[] = {
46640 (char *) "self",(char *) "size", NULL
46641 };
46642
46643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46645 if (!SWIG_IsOK(res1)) {
46646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46647 }
46648 arg1 = reinterpret_cast< wxSizer * >(argp1);
46649 {
46650 arg2 = &temp2;
46651 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46652 }
46653 {
46654 PyThreadState* __tstate = wxPyBeginAllowThreads();
46655 (arg1)->SetMinSize((wxSize const &)*arg2);
46656 wxPyEndAllowThreads(__tstate);
46657 if (PyErr_Occurred()) SWIG_fail;
46658 }
46659 resultobj = SWIG_Py_Void();
46660 return resultobj;
46661 fail:
46662 return NULL;
46663 }
46664
46665
46666 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46667 PyObject *resultobj = 0;
46668 wxSizer *arg1 = (wxSizer *) 0 ;
46669 wxSize result;
46670 void *argp1 = 0 ;
46671 int res1 = 0 ;
46672 PyObject *swig_obj[1] ;
46673
46674 if (!args) SWIG_fail;
46675 swig_obj[0] = args;
46676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46677 if (!SWIG_IsOK(res1)) {
46678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46679 }
46680 arg1 = reinterpret_cast< wxSizer * >(argp1);
46681 {
46682 PyThreadState* __tstate = wxPyBeginAllowThreads();
46683 result = (arg1)->GetSize();
46684 wxPyEndAllowThreads(__tstate);
46685 if (PyErr_Occurred()) SWIG_fail;
46686 }
46687 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46688 return resultobj;
46689 fail:
46690 return NULL;
46691 }
46692
46693
46694 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46695 PyObject *resultobj = 0;
46696 wxSizer *arg1 = (wxSizer *) 0 ;
46697 wxPoint result;
46698 void *argp1 = 0 ;
46699 int res1 = 0 ;
46700 PyObject *swig_obj[1] ;
46701
46702 if (!args) SWIG_fail;
46703 swig_obj[0] = args;
46704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46705 if (!SWIG_IsOK(res1)) {
46706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46707 }
46708 arg1 = reinterpret_cast< wxSizer * >(argp1);
46709 {
46710 PyThreadState* __tstate = wxPyBeginAllowThreads();
46711 result = (arg1)->GetPosition();
46712 wxPyEndAllowThreads(__tstate);
46713 if (PyErr_Occurred()) SWIG_fail;
46714 }
46715 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46716 return resultobj;
46717 fail:
46718 return NULL;
46719 }
46720
46721
46722 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46723 PyObject *resultobj = 0;
46724 wxSizer *arg1 = (wxSizer *) 0 ;
46725 wxSize result;
46726 void *argp1 = 0 ;
46727 int res1 = 0 ;
46728 PyObject *swig_obj[1] ;
46729
46730 if (!args) SWIG_fail;
46731 swig_obj[0] = args;
46732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46735 }
46736 arg1 = reinterpret_cast< wxSizer * >(argp1);
46737 {
46738 PyThreadState* __tstate = wxPyBeginAllowThreads();
46739 result = (arg1)->GetMinSize();
46740 wxPyEndAllowThreads(__tstate);
46741 if (PyErr_Occurred()) SWIG_fail;
46742 }
46743 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46744 return resultobj;
46745 fail:
46746 return NULL;
46747 }
46748
46749
46750 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46751 PyObject *resultobj = 0;
46752 wxSizer *arg1 = (wxSizer *) 0 ;
46753 void *argp1 = 0 ;
46754 int res1 = 0 ;
46755 PyObject *swig_obj[1] ;
46756
46757 if (!args) SWIG_fail;
46758 swig_obj[0] = args;
46759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46760 if (!SWIG_IsOK(res1)) {
46761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46762 }
46763 arg1 = reinterpret_cast< wxSizer * >(argp1);
46764 {
46765 PyThreadState* __tstate = wxPyBeginAllowThreads();
46766 (arg1)->RecalcSizes();
46767 wxPyEndAllowThreads(__tstate);
46768 if (PyErr_Occurred()) SWIG_fail;
46769 }
46770 resultobj = SWIG_Py_Void();
46771 return resultobj;
46772 fail:
46773 return NULL;
46774 }
46775
46776
46777 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46778 PyObject *resultobj = 0;
46779 wxSizer *arg1 = (wxSizer *) 0 ;
46780 wxSize result;
46781 void *argp1 = 0 ;
46782 int res1 = 0 ;
46783 PyObject *swig_obj[1] ;
46784
46785 if (!args) SWIG_fail;
46786 swig_obj[0] = args;
46787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46788 if (!SWIG_IsOK(res1)) {
46789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46790 }
46791 arg1 = reinterpret_cast< wxSizer * >(argp1);
46792 {
46793 PyThreadState* __tstate = wxPyBeginAllowThreads();
46794 result = (arg1)->CalcMin();
46795 wxPyEndAllowThreads(__tstate);
46796 if (PyErr_Occurred()) SWIG_fail;
46797 }
46798 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46799 return resultobj;
46800 fail:
46801 return NULL;
46802 }
46803
46804
46805 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46806 PyObject *resultobj = 0;
46807 wxSizer *arg1 = (wxSizer *) 0 ;
46808 void *argp1 = 0 ;
46809 int res1 = 0 ;
46810 PyObject *swig_obj[1] ;
46811
46812 if (!args) SWIG_fail;
46813 swig_obj[0] = args;
46814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46815 if (!SWIG_IsOK(res1)) {
46816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46817 }
46818 arg1 = reinterpret_cast< wxSizer * >(argp1);
46819 {
46820 PyThreadState* __tstate = wxPyBeginAllowThreads();
46821 (arg1)->Layout();
46822 wxPyEndAllowThreads(__tstate);
46823 if (PyErr_Occurred()) SWIG_fail;
46824 }
46825 resultobj = SWIG_Py_Void();
46826 return resultobj;
46827 fail:
46828 return NULL;
46829 }
46830
46831
46832 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46833 PyObject *resultobj = 0;
46834 wxSizer *arg1 = (wxSizer *) 0 ;
46835 wxWindow *arg2 = (wxWindow *) 0 ;
46836 wxSize result;
46837 void *argp1 = 0 ;
46838 int res1 = 0 ;
46839 void *argp2 = 0 ;
46840 int res2 = 0 ;
46841 PyObject * obj0 = 0 ;
46842 PyObject * obj1 = 0 ;
46843 char * kwnames[] = {
46844 (char *) "self",(char *) "window", NULL
46845 };
46846
46847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46851 }
46852 arg1 = reinterpret_cast< wxSizer * >(argp1);
46853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46854 if (!SWIG_IsOK(res2)) {
46855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46856 }
46857 arg2 = reinterpret_cast< wxWindow * >(argp2);
46858 {
46859 PyThreadState* __tstate = wxPyBeginAllowThreads();
46860 result = (arg1)->Fit(arg2);
46861 wxPyEndAllowThreads(__tstate);
46862 if (PyErr_Occurred()) SWIG_fail;
46863 }
46864 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46865 return resultobj;
46866 fail:
46867 return NULL;
46868 }
46869
46870
46871 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46872 PyObject *resultobj = 0;
46873 wxSizer *arg1 = (wxSizer *) 0 ;
46874 wxWindow *arg2 = (wxWindow *) 0 ;
46875 void *argp1 = 0 ;
46876 int res1 = 0 ;
46877 void *argp2 = 0 ;
46878 int res2 = 0 ;
46879 PyObject * obj0 = 0 ;
46880 PyObject * obj1 = 0 ;
46881 char * kwnames[] = {
46882 (char *) "self",(char *) "window", NULL
46883 };
46884
46885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46887 if (!SWIG_IsOK(res1)) {
46888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46889 }
46890 arg1 = reinterpret_cast< wxSizer * >(argp1);
46891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46892 if (!SWIG_IsOK(res2)) {
46893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46894 }
46895 arg2 = reinterpret_cast< wxWindow * >(argp2);
46896 {
46897 PyThreadState* __tstate = wxPyBeginAllowThreads();
46898 (arg1)->FitInside(arg2);
46899 wxPyEndAllowThreads(__tstate);
46900 if (PyErr_Occurred()) SWIG_fail;
46901 }
46902 resultobj = SWIG_Py_Void();
46903 return resultobj;
46904 fail:
46905 return NULL;
46906 }
46907
46908
46909 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46910 PyObject *resultobj = 0;
46911 wxSizer *arg1 = (wxSizer *) 0 ;
46912 wxWindow *arg2 = (wxWindow *) 0 ;
46913 void *argp1 = 0 ;
46914 int res1 = 0 ;
46915 void *argp2 = 0 ;
46916 int res2 = 0 ;
46917 PyObject * obj0 = 0 ;
46918 PyObject * obj1 = 0 ;
46919 char * kwnames[] = {
46920 (char *) "self",(char *) "window", NULL
46921 };
46922
46923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46925 if (!SWIG_IsOK(res1)) {
46926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46927 }
46928 arg1 = reinterpret_cast< wxSizer * >(argp1);
46929 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46930 if (!SWIG_IsOK(res2)) {
46931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46932 }
46933 arg2 = reinterpret_cast< wxWindow * >(argp2);
46934 {
46935 PyThreadState* __tstate = wxPyBeginAllowThreads();
46936 (arg1)->SetSizeHints(arg2);
46937 wxPyEndAllowThreads(__tstate);
46938 if (PyErr_Occurred()) SWIG_fail;
46939 }
46940 resultobj = SWIG_Py_Void();
46941 return resultobj;
46942 fail:
46943 return NULL;
46944 }
46945
46946
46947 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46948 PyObject *resultobj = 0;
46949 wxSizer *arg1 = (wxSizer *) 0 ;
46950 wxWindow *arg2 = (wxWindow *) 0 ;
46951 void *argp1 = 0 ;
46952 int res1 = 0 ;
46953 void *argp2 = 0 ;
46954 int res2 = 0 ;
46955 PyObject * obj0 = 0 ;
46956 PyObject * obj1 = 0 ;
46957 char * kwnames[] = {
46958 (char *) "self",(char *) "window", NULL
46959 };
46960
46961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46963 if (!SWIG_IsOK(res1)) {
46964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46965 }
46966 arg1 = reinterpret_cast< wxSizer * >(argp1);
46967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46968 if (!SWIG_IsOK(res2)) {
46969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46970 }
46971 arg2 = reinterpret_cast< wxWindow * >(argp2);
46972 {
46973 PyThreadState* __tstate = wxPyBeginAllowThreads();
46974 (arg1)->SetVirtualSizeHints(arg2);
46975 wxPyEndAllowThreads(__tstate);
46976 if (PyErr_Occurred()) SWIG_fail;
46977 }
46978 resultobj = SWIG_Py_Void();
46979 return resultobj;
46980 fail:
46981 return NULL;
46982 }
46983
46984
46985 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46986 PyObject *resultobj = 0;
46987 wxSizer *arg1 = (wxSizer *) 0 ;
46988 bool arg2 = (bool) false ;
46989 void *argp1 = 0 ;
46990 int res1 = 0 ;
46991 bool val2 ;
46992 int ecode2 = 0 ;
46993 PyObject * obj0 = 0 ;
46994 PyObject * obj1 = 0 ;
46995 char * kwnames[] = {
46996 (char *) "self",(char *) "deleteWindows", NULL
46997 };
46998
46999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47001 if (!SWIG_IsOK(res1)) {
47002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47003 }
47004 arg1 = reinterpret_cast< wxSizer * >(argp1);
47005 if (obj1) {
47006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47007 if (!SWIG_IsOK(ecode2)) {
47008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47009 }
47010 arg2 = static_cast< bool >(val2);
47011 }
47012 {
47013 PyThreadState* __tstate = wxPyBeginAllowThreads();
47014 (arg1)->Clear(arg2);
47015 wxPyEndAllowThreads(__tstate);
47016 if (PyErr_Occurred()) SWIG_fail;
47017 }
47018 resultobj = SWIG_Py_Void();
47019 return resultobj;
47020 fail:
47021 return NULL;
47022 }
47023
47024
47025 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47026 PyObject *resultobj = 0;
47027 wxSizer *arg1 = (wxSizer *) 0 ;
47028 void *argp1 = 0 ;
47029 int res1 = 0 ;
47030 PyObject *swig_obj[1] ;
47031
47032 if (!args) SWIG_fail;
47033 swig_obj[0] = args;
47034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47035 if (!SWIG_IsOK(res1)) {
47036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47037 }
47038 arg1 = reinterpret_cast< wxSizer * >(argp1);
47039 {
47040 PyThreadState* __tstate = wxPyBeginAllowThreads();
47041 (arg1)->DeleteWindows();
47042 wxPyEndAllowThreads(__tstate);
47043 if (PyErr_Occurred()) SWIG_fail;
47044 }
47045 resultobj = SWIG_Py_Void();
47046 return resultobj;
47047 fail:
47048 return NULL;
47049 }
47050
47051
47052 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47053 PyObject *resultobj = 0;
47054 wxSizer *arg1 = (wxSizer *) 0 ;
47055 PyObject *result = 0 ;
47056 void *argp1 = 0 ;
47057 int res1 = 0 ;
47058 PyObject *swig_obj[1] ;
47059
47060 if (!args) SWIG_fail;
47061 swig_obj[0] = args;
47062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47063 if (!SWIG_IsOK(res1)) {
47064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47065 }
47066 arg1 = reinterpret_cast< wxSizer * >(argp1);
47067 {
47068 PyThreadState* __tstate = wxPyBeginAllowThreads();
47069 result = (PyObject *)wxSizer_GetChildren(arg1);
47070 wxPyEndAllowThreads(__tstate);
47071 if (PyErr_Occurred()) SWIG_fail;
47072 }
47073 resultobj = result;
47074 return resultobj;
47075 fail:
47076 return NULL;
47077 }
47078
47079
47080 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47081 PyObject *resultobj = 0;
47082 wxSizer *arg1 = (wxSizer *) 0 ;
47083 PyObject *arg2 = (PyObject *) 0 ;
47084 bool arg3 = (bool) true ;
47085 bool arg4 = (bool) false ;
47086 bool result;
47087 void *argp1 = 0 ;
47088 int res1 = 0 ;
47089 bool val3 ;
47090 int ecode3 = 0 ;
47091 bool val4 ;
47092 int ecode4 = 0 ;
47093 PyObject * obj0 = 0 ;
47094 PyObject * obj1 = 0 ;
47095 PyObject * obj2 = 0 ;
47096 PyObject * obj3 = 0 ;
47097 char * kwnames[] = {
47098 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47099 };
47100
47101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47103 if (!SWIG_IsOK(res1)) {
47104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47105 }
47106 arg1 = reinterpret_cast< wxSizer * >(argp1);
47107 arg2 = obj1;
47108 if (obj2) {
47109 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47110 if (!SWIG_IsOK(ecode3)) {
47111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47112 }
47113 arg3 = static_cast< bool >(val3);
47114 }
47115 if (obj3) {
47116 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47117 if (!SWIG_IsOK(ecode4)) {
47118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47119 }
47120 arg4 = static_cast< bool >(val4);
47121 }
47122 {
47123 PyThreadState* __tstate = wxPyBeginAllowThreads();
47124 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47125 wxPyEndAllowThreads(__tstate);
47126 if (PyErr_Occurred()) SWIG_fail;
47127 }
47128 {
47129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47130 }
47131 return resultobj;
47132 fail:
47133 return NULL;
47134 }
47135
47136
47137 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47138 PyObject *resultobj = 0;
47139 wxSizer *arg1 = (wxSizer *) 0 ;
47140 PyObject *arg2 = (PyObject *) 0 ;
47141 bool result;
47142 void *argp1 = 0 ;
47143 int res1 = 0 ;
47144 PyObject * obj0 = 0 ;
47145 PyObject * obj1 = 0 ;
47146 char * kwnames[] = {
47147 (char *) "self",(char *) "item", NULL
47148 };
47149
47150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47152 if (!SWIG_IsOK(res1)) {
47153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47154 }
47155 arg1 = reinterpret_cast< wxSizer * >(argp1);
47156 arg2 = obj1;
47157 {
47158 PyThreadState* __tstate = wxPyBeginAllowThreads();
47159 result = (bool)wxSizer_IsShown(arg1,arg2);
47160 wxPyEndAllowThreads(__tstate);
47161 if (PyErr_Occurred()) SWIG_fail;
47162 }
47163 {
47164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47165 }
47166 return resultobj;
47167 fail:
47168 return NULL;
47169 }
47170
47171
47172 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47173 PyObject *resultobj = 0;
47174 wxSizer *arg1 = (wxSizer *) 0 ;
47175 bool arg2 ;
47176 void *argp1 = 0 ;
47177 int res1 = 0 ;
47178 bool val2 ;
47179 int ecode2 = 0 ;
47180 PyObject * obj0 = 0 ;
47181 PyObject * obj1 = 0 ;
47182 char * kwnames[] = {
47183 (char *) "self",(char *) "show", NULL
47184 };
47185
47186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47188 if (!SWIG_IsOK(res1)) {
47189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47190 }
47191 arg1 = reinterpret_cast< wxSizer * >(argp1);
47192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47193 if (!SWIG_IsOK(ecode2)) {
47194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47195 }
47196 arg2 = static_cast< bool >(val2);
47197 {
47198 PyThreadState* __tstate = wxPyBeginAllowThreads();
47199 (arg1)->ShowItems(arg2);
47200 wxPyEndAllowThreads(__tstate);
47201 if (PyErr_Occurred()) SWIG_fail;
47202 }
47203 resultobj = SWIG_Py_Void();
47204 return resultobj;
47205 fail:
47206 return NULL;
47207 }
47208
47209
47210 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47211 PyObject *obj;
47212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47213 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47214 return SWIG_Py_Void();
47215 }
47216
47217 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47218 PyObject *resultobj = 0;
47219 wxPySizer *result = 0 ;
47220
47221 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47222 {
47223 PyThreadState* __tstate = wxPyBeginAllowThreads();
47224 result = (wxPySizer *)new wxPySizer();
47225 wxPyEndAllowThreads(__tstate);
47226 if (PyErr_Occurred()) SWIG_fail;
47227 }
47228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47229 return resultobj;
47230 fail:
47231 return NULL;
47232 }
47233
47234
47235 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47236 PyObject *resultobj = 0;
47237 wxPySizer *arg1 = (wxPySizer *) 0 ;
47238 PyObject *arg2 = (PyObject *) 0 ;
47239 PyObject *arg3 = (PyObject *) 0 ;
47240 void *argp1 = 0 ;
47241 int res1 = 0 ;
47242 PyObject * obj0 = 0 ;
47243 PyObject * obj1 = 0 ;
47244 PyObject * obj2 = 0 ;
47245 char * kwnames[] = {
47246 (char *) "self",(char *) "self",(char *) "_class", NULL
47247 };
47248
47249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47251 if (!SWIG_IsOK(res1)) {
47252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47253 }
47254 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47255 arg2 = obj1;
47256 arg3 = obj2;
47257 {
47258 PyThreadState* __tstate = wxPyBeginAllowThreads();
47259 (arg1)->_setCallbackInfo(arg2,arg3);
47260 wxPyEndAllowThreads(__tstate);
47261 if (PyErr_Occurred()) SWIG_fail;
47262 }
47263 resultobj = SWIG_Py_Void();
47264 return resultobj;
47265 fail:
47266 return NULL;
47267 }
47268
47269
47270 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47271 PyObject *obj;
47272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47273 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47274 return SWIG_Py_Void();
47275 }
47276
47277 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47278 return SWIG_Python_InitShadowInstance(args);
47279 }
47280
47281 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47282 PyObject *resultobj = 0;
47283 int arg1 = (int) wxHORIZONTAL ;
47284 wxBoxSizer *result = 0 ;
47285 int val1 ;
47286 int ecode1 = 0 ;
47287 PyObject * obj0 = 0 ;
47288 char * kwnames[] = {
47289 (char *) "orient", NULL
47290 };
47291
47292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47293 if (obj0) {
47294 ecode1 = SWIG_AsVal_int(obj0, &val1);
47295 if (!SWIG_IsOK(ecode1)) {
47296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47297 }
47298 arg1 = static_cast< int >(val1);
47299 }
47300 {
47301 PyThreadState* __tstate = wxPyBeginAllowThreads();
47302 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47303 wxPyEndAllowThreads(__tstate);
47304 if (PyErr_Occurred()) SWIG_fail;
47305 }
47306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47307 return resultobj;
47308 fail:
47309 return NULL;
47310 }
47311
47312
47313 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47314 PyObject *resultobj = 0;
47315 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47316 int result;
47317 void *argp1 = 0 ;
47318 int res1 = 0 ;
47319 PyObject *swig_obj[1] ;
47320
47321 if (!args) SWIG_fail;
47322 swig_obj[0] = args;
47323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47324 if (!SWIG_IsOK(res1)) {
47325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47326 }
47327 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47328 {
47329 PyThreadState* __tstate = wxPyBeginAllowThreads();
47330 result = (int)(arg1)->GetOrientation();
47331 wxPyEndAllowThreads(__tstate);
47332 if (PyErr_Occurred()) SWIG_fail;
47333 }
47334 resultobj = SWIG_From_int(static_cast< int >(result));
47335 return resultobj;
47336 fail:
47337 return NULL;
47338 }
47339
47340
47341 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47342 PyObject *resultobj = 0;
47343 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47344 int arg2 ;
47345 void *argp1 = 0 ;
47346 int res1 = 0 ;
47347 int val2 ;
47348 int ecode2 = 0 ;
47349 PyObject * obj0 = 0 ;
47350 PyObject * obj1 = 0 ;
47351 char * kwnames[] = {
47352 (char *) "self",(char *) "orient", NULL
47353 };
47354
47355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47357 if (!SWIG_IsOK(res1)) {
47358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47359 }
47360 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47361 ecode2 = SWIG_AsVal_int(obj1, &val2);
47362 if (!SWIG_IsOK(ecode2)) {
47363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47364 }
47365 arg2 = static_cast< int >(val2);
47366 {
47367 PyThreadState* __tstate = wxPyBeginAllowThreads();
47368 (arg1)->SetOrientation(arg2);
47369 wxPyEndAllowThreads(__tstate);
47370 if (PyErr_Occurred()) SWIG_fail;
47371 }
47372 resultobj = SWIG_Py_Void();
47373 return resultobj;
47374 fail:
47375 return NULL;
47376 }
47377
47378
47379 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47380 PyObject *obj;
47381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47382 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47383 return SWIG_Py_Void();
47384 }
47385
47386 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47387 return SWIG_Python_InitShadowInstance(args);
47388 }
47389
47390 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47391 PyObject *resultobj = 0;
47392 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47393 int arg2 = (int) wxHORIZONTAL ;
47394 wxStaticBoxSizer *result = 0 ;
47395 void *argp1 = 0 ;
47396 int res1 = 0 ;
47397 int val2 ;
47398 int ecode2 = 0 ;
47399 PyObject * obj0 = 0 ;
47400 PyObject * obj1 = 0 ;
47401 char * kwnames[] = {
47402 (char *) "box",(char *) "orient", NULL
47403 };
47404
47405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47407 if (!SWIG_IsOK(res1)) {
47408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47409 }
47410 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47411 if (obj1) {
47412 ecode2 = SWIG_AsVal_int(obj1, &val2);
47413 if (!SWIG_IsOK(ecode2)) {
47414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47415 }
47416 arg2 = static_cast< int >(val2);
47417 }
47418 {
47419 PyThreadState* __tstate = wxPyBeginAllowThreads();
47420 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47421 wxPyEndAllowThreads(__tstate);
47422 if (PyErr_Occurred()) SWIG_fail;
47423 }
47424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47425 return resultobj;
47426 fail:
47427 return NULL;
47428 }
47429
47430
47431 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47432 PyObject *resultobj = 0;
47433 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47434 wxStaticBox *result = 0 ;
47435 void *argp1 = 0 ;
47436 int res1 = 0 ;
47437 PyObject *swig_obj[1] ;
47438
47439 if (!args) SWIG_fail;
47440 swig_obj[0] = args;
47441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47442 if (!SWIG_IsOK(res1)) {
47443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47444 }
47445 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 result = (wxStaticBox *)(arg1)->GetStaticBox();
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 {
47453 resultobj = wxPyMake_wxObject(result, (bool)0);
47454 }
47455 return resultobj;
47456 fail:
47457 return NULL;
47458 }
47459
47460
47461 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47462 PyObject *obj;
47463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47464 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47465 return SWIG_Py_Void();
47466 }
47467
47468 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47469 return SWIG_Python_InitShadowInstance(args);
47470 }
47471
47472 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47473 PyObject *resultobj = 0;
47474 int arg1 = (int) 1 ;
47475 int arg2 = (int) 0 ;
47476 int arg3 = (int) 0 ;
47477 int arg4 = (int) 0 ;
47478 wxGridSizer *result = 0 ;
47479 int val1 ;
47480 int ecode1 = 0 ;
47481 int val2 ;
47482 int ecode2 = 0 ;
47483 int val3 ;
47484 int ecode3 = 0 ;
47485 int val4 ;
47486 int ecode4 = 0 ;
47487 PyObject * obj0 = 0 ;
47488 PyObject * obj1 = 0 ;
47489 PyObject * obj2 = 0 ;
47490 PyObject * obj3 = 0 ;
47491 char * kwnames[] = {
47492 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47493 };
47494
47495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47496 if (obj0) {
47497 ecode1 = SWIG_AsVal_int(obj0, &val1);
47498 if (!SWIG_IsOK(ecode1)) {
47499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47500 }
47501 arg1 = static_cast< int >(val1);
47502 }
47503 if (obj1) {
47504 ecode2 = SWIG_AsVal_int(obj1, &val2);
47505 if (!SWIG_IsOK(ecode2)) {
47506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47507 }
47508 arg2 = static_cast< int >(val2);
47509 }
47510 if (obj2) {
47511 ecode3 = SWIG_AsVal_int(obj2, &val3);
47512 if (!SWIG_IsOK(ecode3)) {
47513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47514 }
47515 arg3 = static_cast< int >(val3);
47516 }
47517 if (obj3) {
47518 ecode4 = SWIG_AsVal_int(obj3, &val4);
47519 if (!SWIG_IsOK(ecode4)) {
47520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47521 }
47522 arg4 = static_cast< int >(val4);
47523 }
47524 {
47525 PyThreadState* __tstate = wxPyBeginAllowThreads();
47526 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47527 wxPyEndAllowThreads(__tstate);
47528 if (PyErr_Occurred()) SWIG_fail;
47529 }
47530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47531 return resultobj;
47532 fail:
47533 return NULL;
47534 }
47535
47536
47537 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47538 PyObject *resultobj = 0;
47539 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47540 int arg2 ;
47541 void *argp1 = 0 ;
47542 int res1 = 0 ;
47543 int val2 ;
47544 int ecode2 = 0 ;
47545 PyObject * obj0 = 0 ;
47546 PyObject * obj1 = 0 ;
47547 char * kwnames[] = {
47548 (char *) "self",(char *) "cols", NULL
47549 };
47550
47551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47553 if (!SWIG_IsOK(res1)) {
47554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47555 }
47556 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47557 ecode2 = SWIG_AsVal_int(obj1, &val2);
47558 if (!SWIG_IsOK(ecode2)) {
47559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47560 }
47561 arg2 = static_cast< int >(val2);
47562 {
47563 PyThreadState* __tstate = wxPyBeginAllowThreads();
47564 (arg1)->SetCols(arg2);
47565 wxPyEndAllowThreads(__tstate);
47566 if (PyErr_Occurred()) SWIG_fail;
47567 }
47568 resultobj = SWIG_Py_Void();
47569 return resultobj;
47570 fail:
47571 return NULL;
47572 }
47573
47574
47575 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47576 PyObject *resultobj = 0;
47577 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47578 int arg2 ;
47579 void *argp1 = 0 ;
47580 int res1 = 0 ;
47581 int val2 ;
47582 int ecode2 = 0 ;
47583 PyObject * obj0 = 0 ;
47584 PyObject * obj1 = 0 ;
47585 char * kwnames[] = {
47586 (char *) "self",(char *) "rows", NULL
47587 };
47588
47589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47591 if (!SWIG_IsOK(res1)) {
47592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47593 }
47594 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47595 ecode2 = SWIG_AsVal_int(obj1, &val2);
47596 if (!SWIG_IsOK(ecode2)) {
47597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47598 }
47599 arg2 = static_cast< int >(val2);
47600 {
47601 PyThreadState* __tstate = wxPyBeginAllowThreads();
47602 (arg1)->SetRows(arg2);
47603 wxPyEndAllowThreads(__tstate);
47604 if (PyErr_Occurred()) SWIG_fail;
47605 }
47606 resultobj = SWIG_Py_Void();
47607 return resultobj;
47608 fail:
47609 return NULL;
47610 }
47611
47612
47613 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47614 PyObject *resultobj = 0;
47615 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47616 int arg2 ;
47617 void *argp1 = 0 ;
47618 int res1 = 0 ;
47619 int val2 ;
47620 int ecode2 = 0 ;
47621 PyObject * obj0 = 0 ;
47622 PyObject * obj1 = 0 ;
47623 char * kwnames[] = {
47624 (char *) "self",(char *) "gap", NULL
47625 };
47626
47627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47629 if (!SWIG_IsOK(res1)) {
47630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47631 }
47632 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47633 ecode2 = SWIG_AsVal_int(obj1, &val2);
47634 if (!SWIG_IsOK(ecode2)) {
47635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47636 }
47637 arg2 = static_cast< int >(val2);
47638 {
47639 PyThreadState* __tstate = wxPyBeginAllowThreads();
47640 (arg1)->SetVGap(arg2);
47641 wxPyEndAllowThreads(__tstate);
47642 if (PyErr_Occurred()) SWIG_fail;
47643 }
47644 resultobj = SWIG_Py_Void();
47645 return resultobj;
47646 fail:
47647 return NULL;
47648 }
47649
47650
47651 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47652 PyObject *resultobj = 0;
47653 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47654 int arg2 ;
47655 void *argp1 = 0 ;
47656 int res1 = 0 ;
47657 int val2 ;
47658 int ecode2 = 0 ;
47659 PyObject * obj0 = 0 ;
47660 PyObject * obj1 = 0 ;
47661 char * kwnames[] = {
47662 (char *) "self",(char *) "gap", NULL
47663 };
47664
47665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47667 if (!SWIG_IsOK(res1)) {
47668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47669 }
47670 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47671 ecode2 = SWIG_AsVal_int(obj1, &val2);
47672 if (!SWIG_IsOK(ecode2)) {
47673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47674 }
47675 arg2 = static_cast< int >(val2);
47676 {
47677 PyThreadState* __tstate = wxPyBeginAllowThreads();
47678 (arg1)->SetHGap(arg2);
47679 wxPyEndAllowThreads(__tstate);
47680 if (PyErr_Occurred()) SWIG_fail;
47681 }
47682 resultobj = SWIG_Py_Void();
47683 return resultobj;
47684 fail:
47685 return NULL;
47686 }
47687
47688
47689 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47690 PyObject *resultobj = 0;
47691 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47692 int result;
47693 void *argp1 = 0 ;
47694 int res1 = 0 ;
47695 PyObject *swig_obj[1] ;
47696
47697 if (!args) SWIG_fail;
47698 swig_obj[0] = args;
47699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47700 if (!SWIG_IsOK(res1)) {
47701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47702 }
47703 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47704 {
47705 PyThreadState* __tstate = wxPyBeginAllowThreads();
47706 result = (int)(arg1)->GetCols();
47707 wxPyEndAllowThreads(__tstate);
47708 if (PyErr_Occurred()) SWIG_fail;
47709 }
47710 resultobj = SWIG_From_int(static_cast< int >(result));
47711 return resultobj;
47712 fail:
47713 return NULL;
47714 }
47715
47716
47717 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47718 PyObject *resultobj = 0;
47719 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47720 int result;
47721 void *argp1 = 0 ;
47722 int res1 = 0 ;
47723 PyObject *swig_obj[1] ;
47724
47725 if (!args) SWIG_fail;
47726 swig_obj[0] = args;
47727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47728 if (!SWIG_IsOK(res1)) {
47729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47730 }
47731 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47732 {
47733 PyThreadState* __tstate = wxPyBeginAllowThreads();
47734 result = (int)(arg1)->GetRows();
47735 wxPyEndAllowThreads(__tstate);
47736 if (PyErr_Occurred()) SWIG_fail;
47737 }
47738 resultobj = SWIG_From_int(static_cast< int >(result));
47739 return resultobj;
47740 fail:
47741 return NULL;
47742 }
47743
47744
47745 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47746 PyObject *resultobj = 0;
47747 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47748 int result;
47749 void *argp1 = 0 ;
47750 int res1 = 0 ;
47751 PyObject *swig_obj[1] ;
47752
47753 if (!args) SWIG_fail;
47754 swig_obj[0] = args;
47755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47756 if (!SWIG_IsOK(res1)) {
47757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47758 }
47759 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47760 {
47761 PyThreadState* __tstate = wxPyBeginAllowThreads();
47762 result = (int)(arg1)->GetVGap();
47763 wxPyEndAllowThreads(__tstate);
47764 if (PyErr_Occurred()) SWIG_fail;
47765 }
47766 resultobj = SWIG_From_int(static_cast< int >(result));
47767 return resultobj;
47768 fail:
47769 return NULL;
47770 }
47771
47772
47773 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47774 PyObject *resultobj = 0;
47775 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47776 int result;
47777 void *argp1 = 0 ;
47778 int res1 = 0 ;
47779 PyObject *swig_obj[1] ;
47780
47781 if (!args) SWIG_fail;
47782 swig_obj[0] = args;
47783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47784 if (!SWIG_IsOK(res1)) {
47785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47786 }
47787 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47788 {
47789 PyThreadState* __tstate = wxPyBeginAllowThreads();
47790 result = (int)(arg1)->GetHGap();
47791 wxPyEndAllowThreads(__tstate);
47792 if (PyErr_Occurred()) SWIG_fail;
47793 }
47794 resultobj = SWIG_From_int(static_cast< int >(result));
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47802 PyObject *obj;
47803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47804 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47805 return SWIG_Py_Void();
47806 }
47807
47808 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47809 return SWIG_Python_InitShadowInstance(args);
47810 }
47811
47812 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47813 PyObject *resultobj = 0;
47814 int arg1 = (int) 1 ;
47815 int arg2 = (int) 0 ;
47816 int arg3 = (int) 0 ;
47817 int arg4 = (int) 0 ;
47818 wxFlexGridSizer *result = 0 ;
47819 int val1 ;
47820 int ecode1 = 0 ;
47821 int val2 ;
47822 int ecode2 = 0 ;
47823 int val3 ;
47824 int ecode3 = 0 ;
47825 int val4 ;
47826 int ecode4 = 0 ;
47827 PyObject * obj0 = 0 ;
47828 PyObject * obj1 = 0 ;
47829 PyObject * obj2 = 0 ;
47830 PyObject * obj3 = 0 ;
47831 char * kwnames[] = {
47832 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47833 };
47834
47835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47836 if (obj0) {
47837 ecode1 = SWIG_AsVal_int(obj0, &val1);
47838 if (!SWIG_IsOK(ecode1)) {
47839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47840 }
47841 arg1 = static_cast< int >(val1);
47842 }
47843 if (obj1) {
47844 ecode2 = SWIG_AsVal_int(obj1, &val2);
47845 if (!SWIG_IsOK(ecode2)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47847 }
47848 arg2 = static_cast< int >(val2);
47849 }
47850 if (obj2) {
47851 ecode3 = SWIG_AsVal_int(obj2, &val3);
47852 if (!SWIG_IsOK(ecode3)) {
47853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47854 }
47855 arg3 = static_cast< int >(val3);
47856 }
47857 if (obj3) {
47858 ecode4 = SWIG_AsVal_int(obj3, &val4);
47859 if (!SWIG_IsOK(ecode4)) {
47860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47861 }
47862 arg4 = static_cast< int >(val4);
47863 }
47864 {
47865 PyThreadState* __tstate = wxPyBeginAllowThreads();
47866 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47867 wxPyEndAllowThreads(__tstate);
47868 if (PyErr_Occurred()) SWIG_fail;
47869 }
47870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47871 return resultobj;
47872 fail:
47873 return NULL;
47874 }
47875
47876
47877 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47878 PyObject *resultobj = 0;
47879 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47880 size_t arg2 ;
47881 int arg3 = (int) 0 ;
47882 void *argp1 = 0 ;
47883 int res1 = 0 ;
47884 size_t val2 ;
47885 int ecode2 = 0 ;
47886 int val3 ;
47887 int ecode3 = 0 ;
47888 PyObject * obj0 = 0 ;
47889 PyObject * obj1 = 0 ;
47890 PyObject * obj2 = 0 ;
47891 char * kwnames[] = {
47892 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47893 };
47894
47895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47897 if (!SWIG_IsOK(res1)) {
47898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47899 }
47900 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47901 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47902 if (!SWIG_IsOK(ecode2)) {
47903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47904 }
47905 arg2 = static_cast< size_t >(val2);
47906 if (obj2) {
47907 ecode3 = SWIG_AsVal_int(obj2, &val3);
47908 if (!SWIG_IsOK(ecode3)) {
47909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47910 }
47911 arg3 = static_cast< int >(val3);
47912 }
47913 {
47914 PyThreadState* __tstate = wxPyBeginAllowThreads();
47915 (arg1)->AddGrowableRow(arg2,arg3);
47916 wxPyEndAllowThreads(__tstate);
47917 if (PyErr_Occurred()) SWIG_fail;
47918 }
47919 resultobj = SWIG_Py_Void();
47920 return resultobj;
47921 fail:
47922 return NULL;
47923 }
47924
47925
47926 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47927 PyObject *resultobj = 0;
47928 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47929 size_t arg2 ;
47930 void *argp1 = 0 ;
47931 int res1 = 0 ;
47932 size_t val2 ;
47933 int ecode2 = 0 ;
47934 PyObject * obj0 = 0 ;
47935 PyObject * obj1 = 0 ;
47936 char * kwnames[] = {
47937 (char *) "self",(char *) "idx", NULL
47938 };
47939
47940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47942 if (!SWIG_IsOK(res1)) {
47943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47944 }
47945 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47946 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47947 if (!SWIG_IsOK(ecode2)) {
47948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47949 }
47950 arg2 = static_cast< size_t >(val2);
47951 {
47952 PyThreadState* __tstate = wxPyBeginAllowThreads();
47953 (arg1)->RemoveGrowableRow(arg2);
47954 wxPyEndAllowThreads(__tstate);
47955 if (PyErr_Occurred()) SWIG_fail;
47956 }
47957 resultobj = SWIG_Py_Void();
47958 return resultobj;
47959 fail:
47960 return NULL;
47961 }
47962
47963
47964 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47965 PyObject *resultobj = 0;
47966 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47967 size_t arg2 ;
47968 int arg3 = (int) 0 ;
47969 void *argp1 = 0 ;
47970 int res1 = 0 ;
47971 size_t val2 ;
47972 int ecode2 = 0 ;
47973 int val3 ;
47974 int ecode3 = 0 ;
47975 PyObject * obj0 = 0 ;
47976 PyObject * obj1 = 0 ;
47977 PyObject * obj2 = 0 ;
47978 char * kwnames[] = {
47979 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47980 };
47981
47982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47984 if (!SWIG_IsOK(res1)) {
47985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47986 }
47987 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47988 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47989 if (!SWIG_IsOK(ecode2)) {
47990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47991 }
47992 arg2 = static_cast< size_t >(val2);
47993 if (obj2) {
47994 ecode3 = SWIG_AsVal_int(obj2, &val3);
47995 if (!SWIG_IsOK(ecode3)) {
47996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47997 }
47998 arg3 = static_cast< int >(val3);
47999 }
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 (arg1)->AddGrowableCol(arg2,arg3);
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 resultobj = SWIG_Py_Void();
48007 return resultobj;
48008 fail:
48009 return NULL;
48010 }
48011
48012
48013 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48014 PyObject *resultobj = 0;
48015 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48016 size_t arg2 ;
48017 void *argp1 = 0 ;
48018 int res1 = 0 ;
48019 size_t val2 ;
48020 int ecode2 = 0 ;
48021 PyObject * obj0 = 0 ;
48022 PyObject * obj1 = 0 ;
48023 char * kwnames[] = {
48024 (char *) "self",(char *) "idx", NULL
48025 };
48026
48027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48029 if (!SWIG_IsOK(res1)) {
48030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48031 }
48032 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48033 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48034 if (!SWIG_IsOK(ecode2)) {
48035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48036 }
48037 arg2 = static_cast< size_t >(val2);
48038 {
48039 PyThreadState* __tstate = wxPyBeginAllowThreads();
48040 (arg1)->RemoveGrowableCol(arg2);
48041 wxPyEndAllowThreads(__tstate);
48042 if (PyErr_Occurred()) SWIG_fail;
48043 }
48044 resultobj = SWIG_Py_Void();
48045 return resultobj;
48046 fail:
48047 return NULL;
48048 }
48049
48050
48051 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48052 PyObject *resultobj = 0;
48053 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48054 int arg2 ;
48055 void *argp1 = 0 ;
48056 int res1 = 0 ;
48057 int val2 ;
48058 int ecode2 = 0 ;
48059 PyObject * obj0 = 0 ;
48060 PyObject * obj1 = 0 ;
48061 char * kwnames[] = {
48062 (char *) "self",(char *) "direction", NULL
48063 };
48064
48065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48067 if (!SWIG_IsOK(res1)) {
48068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48069 }
48070 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48071 ecode2 = SWIG_AsVal_int(obj1, &val2);
48072 if (!SWIG_IsOK(ecode2)) {
48073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48074 }
48075 arg2 = static_cast< int >(val2);
48076 {
48077 PyThreadState* __tstate = wxPyBeginAllowThreads();
48078 (arg1)->SetFlexibleDirection(arg2);
48079 wxPyEndAllowThreads(__tstate);
48080 if (PyErr_Occurred()) SWIG_fail;
48081 }
48082 resultobj = SWIG_Py_Void();
48083 return resultobj;
48084 fail:
48085 return NULL;
48086 }
48087
48088
48089 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48090 PyObject *resultobj = 0;
48091 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48092 int result;
48093 void *argp1 = 0 ;
48094 int res1 = 0 ;
48095 PyObject *swig_obj[1] ;
48096
48097 if (!args) SWIG_fail;
48098 swig_obj[0] = args;
48099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48100 if (!SWIG_IsOK(res1)) {
48101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48102 }
48103 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48104 {
48105 PyThreadState* __tstate = wxPyBeginAllowThreads();
48106 result = (int)(arg1)->GetFlexibleDirection();
48107 wxPyEndAllowThreads(__tstate);
48108 if (PyErr_Occurred()) SWIG_fail;
48109 }
48110 resultobj = SWIG_From_int(static_cast< int >(result));
48111 return resultobj;
48112 fail:
48113 return NULL;
48114 }
48115
48116
48117 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48118 PyObject *resultobj = 0;
48119 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48120 wxFlexSizerGrowMode arg2 ;
48121 void *argp1 = 0 ;
48122 int res1 = 0 ;
48123 int val2 ;
48124 int ecode2 = 0 ;
48125 PyObject * obj0 = 0 ;
48126 PyObject * obj1 = 0 ;
48127 char * kwnames[] = {
48128 (char *) "self",(char *) "mode", NULL
48129 };
48130
48131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48133 if (!SWIG_IsOK(res1)) {
48134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48135 }
48136 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48137 ecode2 = SWIG_AsVal_int(obj1, &val2);
48138 if (!SWIG_IsOK(ecode2)) {
48139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48140 }
48141 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48142 {
48143 PyThreadState* __tstate = wxPyBeginAllowThreads();
48144 (arg1)->SetNonFlexibleGrowMode(arg2);
48145 wxPyEndAllowThreads(__tstate);
48146 if (PyErr_Occurred()) SWIG_fail;
48147 }
48148 resultobj = SWIG_Py_Void();
48149 return resultobj;
48150 fail:
48151 return NULL;
48152 }
48153
48154
48155 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48156 PyObject *resultobj = 0;
48157 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48158 wxFlexSizerGrowMode result;
48159 void *argp1 = 0 ;
48160 int res1 = 0 ;
48161 PyObject *swig_obj[1] ;
48162
48163 if (!args) SWIG_fail;
48164 swig_obj[0] = args;
48165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48166 if (!SWIG_IsOK(res1)) {
48167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48168 }
48169 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48170 {
48171 PyThreadState* __tstate = wxPyBeginAllowThreads();
48172 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48173 wxPyEndAllowThreads(__tstate);
48174 if (PyErr_Occurred()) SWIG_fail;
48175 }
48176 resultobj = SWIG_From_int(static_cast< int >(result));
48177 return resultobj;
48178 fail:
48179 return NULL;
48180 }
48181
48182
48183 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48184 PyObject *resultobj = 0;
48185 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48186 wxArrayInt *result = 0 ;
48187 void *argp1 = 0 ;
48188 int res1 = 0 ;
48189 PyObject *swig_obj[1] ;
48190
48191 if (!args) SWIG_fail;
48192 swig_obj[0] = args;
48193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48194 if (!SWIG_IsOK(res1)) {
48195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48196 }
48197 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48198 {
48199 PyThreadState* __tstate = wxPyBeginAllowThreads();
48200 {
48201 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48202 result = (wxArrayInt *) &_result_ref;
48203 }
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 {
48208 resultobj = PyList_New(0);
48209 size_t idx;
48210 for (idx = 0; idx < result->GetCount(); idx += 1) {
48211 PyObject* val = PyInt_FromLong( result->Item(idx) );
48212 PyList_Append(resultobj, val);
48213 Py_DECREF(val);
48214 }
48215 }
48216 return resultobj;
48217 fail:
48218 return NULL;
48219 }
48220
48221
48222 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48223 PyObject *resultobj = 0;
48224 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48225 wxArrayInt *result = 0 ;
48226 void *argp1 = 0 ;
48227 int res1 = 0 ;
48228 PyObject *swig_obj[1] ;
48229
48230 if (!args) SWIG_fail;
48231 swig_obj[0] = args;
48232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48233 if (!SWIG_IsOK(res1)) {
48234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48235 }
48236 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48237 {
48238 PyThreadState* __tstate = wxPyBeginAllowThreads();
48239 {
48240 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48241 result = (wxArrayInt *) &_result_ref;
48242 }
48243 wxPyEndAllowThreads(__tstate);
48244 if (PyErr_Occurred()) SWIG_fail;
48245 }
48246 {
48247 resultobj = PyList_New(0);
48248 size_t idx;
48249 for (idx = 0; idx < result->GetCount(); idx += 1) {
48250 PyObject* val = PyInt_FromLong( result->Item(idx) );
48251 PyList_Append(resultobj, val);
48252 Py_DECREF(val);
48253 }
48254 }
48255 return resultobj;
48256 fail:
48257 return NULL;
48258 }
48259
48260
48261 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48262 PyObject *obj;
48263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48264 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48265 return SWIG_Py_Void();
48266 }
48267
48268 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48269 return SWIG_Python_InitShadowInstance(args);
48270 }
48271
48272 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48273 PyObject *resultobj = 0;
48274 wxStdDialogButtonSizer *result = 0 ;
48275
48276 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48277 {
48278 PyThreadState* __tstate = wxPyBeginAllowThreads();
48279 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48280 wxPyEndAllowThreads(__tstate);
48281 if (PyErr_Occurred()) SWIG_fail;
48282 }
48283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48284 return resultobj;
48285 fail:
48286 return NULL;
48287 }
48288
48289
48290 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48291 PyObject *resultobj = 0;
48292 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48293 wxButton *arg2 = (wxButton *) 0 ;
48294 void *argp1 = 0 ;
48295 int res1 = 0 ;
48296 void *argp2 = 0 ;
48297 int res2 = 0 ;
48298 PyObject * obj0 = 0 ;
48299 PyObject * obj1 = 0 ;
48300 char * kwnames[] = {
48301 (char *) "self",(char *) "button", NULL
48302 };
48303
48304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48306 if (!SWIG_IsOK(res1)) {
48307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48308 }
48309 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48311 if (!SWIG_IsOK(res2)) {
48312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48313 }
48314 arg2 = reinterpret_cast< wxButton * >(argp2);
48315 {
48316 PyThreadState* __tstate = wxPyBeginAllowThreads();
48317 (arg1)->AddButton(arg2);
48318 wxPyEndAllowThreads(__tstate);
48319 if (PyErr_Occurred()) SWIG_fail;
48320 }
48321 resultobj = SWIG_Py_Void();
48322 return resultobj;
48323 fail:
48324 return NULL;
48325 }
48326
48327
48328 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48329 PyObject *resultobj = 0;
48330 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48331 void *argp1 = 0 ;
48332 int res1 = 0 ;
48333 PyObject *swig_obj[1] ;
48334
48335 if (!args) SWIG_fail;
48336 swig_obj[0] = args;
48337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48338 if (!SWIG_IsOK(res1)) {
48339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48340 }
48341 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48342 {
48343 PyThreadState* __tstate = wxPyBeginAllowThreads();
48344 (arg1)->Realize();
48345 wxPyEndAllowThreads(__tstate);
48346 if (PyErr_Occurred()) SWIG_fail;
48347 }
48348 resultobj = SWIG_Py_Void();
48349 return resultobj;
48350 fail:
48351 return NULL;
48352 }
48353
48354
48355 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48356 PyObject *resultobj = 0;
48357 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48358 wxButton *arg2 = (wxButton *) 0 ;
48359 void *argp1 = 0 ;
48360 int res1 = 0 ;
48361 void *argp2 = 0 ;
48362 int res2 = 0 ;
48363 PyObject * obj0 = 0 ;
48364 PyObject * obj1 = 0 ;
48365 char * kwnames[] = {
48366 (char *) "self",(char *) "button", NULL
48367 };
48368
48369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48371 if (!SWIG_IsOK(res1)) {
48372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48373 }
48374 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48376 if (!SWIG_IsOK(res2)) {
48377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48378 }
48379 arg2 = reinterpret_cast< wxButton * >(argp2);
48380 {
48381 PyThreadState* __tstate = wxPyBeginAllowThreads();
48382 (arg1)->SetAffirmativeButton(arg2);
48383 wxPyEndAllowThreads(__tstate);
48384 if (PyErr_Occurred()) SWIG_fail;
48385 }
48386 resultobj = SWIG_Py_Void();
48387 return resultobj;
48388 fail:
48389 return NULL;
48390 }
48391
48392
48393 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48394 PyObject *resultobj = 0;
48395 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48396 wxButton *arg2 = (wxButton *) 0 ;
48397 void *argp1 = 0 ;
48398 int res1 = 0 ;
48399 void *argp2 = 0 ;
48400 int res2 = 0 ;
48401 PyObject * obj0 = 0 ;
48402 PyObject * obj1 = 0 ;
48403 char * kwnames[] = {
48404 (char *) "self",(char *) "button", NULL
48405 };
48406
48407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48409 if (!SWIG_IsOK(res1)) {
48410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48411 }
48412 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48414 if (!SWIG_IsOK(res2)) {
48415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48416 }
48417 arg2 = reinterpret_cast< wxButton * >(argp2);
48418 {
48419 PyThreadState* __tstate = wxPyBeginAllowThreads();
48420 (arg1)->SetNegativeButton(arg2);
48421 wxPyEndAllowThreads(__tstate);
48422 if (PyErr_Occurred()) SWIG_fail;
48423 }
48424 resultobj = SWIG_Py_Void();
48425 return resultobj;
48426 fail:
48427 return NULL;
48428 }
48429
48430
48431 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48432 PyObject *resultobj = 0;
48433 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48434 wxButton *arg2 = (wxButton *) 0 ;
48435 void *argp1 = 0 ;
48436 int res1 = 0 ;
48437 void *argp2 = 0 ;
48438 int res2 = 0 ;
48439 PyObject * obj0 = 0 ;
48440 PyObject * obj1 = 0 ;
48441 char * kwnames[] = {
48442 (char *) "self",(char *) "button", NULL
48443 };
48444
48445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48447 if (!SWIG_IsOK(res1)) {
48448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48449 }
48450 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48452 if (!SWIG_IsOK(res2)) {
48453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48454 }
48455 arg2 = reinterpret_cast< wxButton * >(argp2);
48456 {
48457 PyThreadState* __tstate = wxPyBeginAllowThreads();
48458 (arg1)->SetCancelButton(arg2);
48459 wxPyEndAllowThreads(__tstate);
48460 if (PyErr_Occurred()) SWIG_fail;
48461 }
48462 resultobj = SWIG_Py_Void();
48463 return resultobj;
48464 fail:
48465 return NULL;
48466 }
48467
48468
48469 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48470 PyObject *resultobj = 0;
48471 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48472 wxButton *result = 0 ;
48473 void *argp1 = 0 ;
48474 int res1 = 0 ;
48475 PyObject *swig_obj[1] ;
48476
48477 if (!args) SWIG_fail;
48478 swig_obj[0] = args;
48479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48480 if (!SWIG_IsOK(res1)) {
48481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48482 }
48483 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48484 {
48485 PyThreadState* __tstate = wxPyBeginAllowThreads();
48486 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48487 wxPyEndAllowThreads(__tstate);
48488 if (PyErr_Occurred()) SWIG_fail;
48489 }
48490 {
48491 resultobj = wxPyMake_wxObject(result, (bool)0);
48492 }
48493 return resultobj;
48494 fail:
48495 return NULL;
48496 }
48497
48498
48499 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48500 PyObject *resultobj = 0;
48501 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48502 wxButton *result = 0 ;
48503 void *argp1 = 0 ;
48504 int res1 = 0 ;
48505 PyObject *swig_obj[1] ;
48506
48507 if (!args) SWIG_fail;
48508 swig_obj[0] = args;
48509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48510 if (!SWIG_IsOK(res1)) {
48511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48512 }
48513 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 {
48521 resultobj = wxPyMake_wxObject(result, (bool)0);
48522 }
48523 return resultobj;
48524 fail:
48525 return NULL;
48526 }
48527
48528
48529 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48530 PyObject *resultobj = 0;
48531 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48532 wxButton *result = 0 ;
48533 void *argp1 = 0 ;
48534 int res1 = 0 ;
48535 PyObject *swig_obj[1] ;
48536
48537 if (!args) SWIG_fail;
48538 swig_obj[0] = args;
48539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48540 if (!SWIG_IsOK(res1)) {
48541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48542 }
48543 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48544 {
48545 PyThreadState* __tstate = wxPyBeginAllowThreads();
48546 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48547 wxPyEndAllowThreads(__tstate);
48548 if (PyErr_Occurred()) SWIG_fail;
48549 }
48550 {
48551 resultobj = wxPyMake_wxObject(result, (bool)0);
48552 }
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48562 wxButton *result = 0 ;
48563 void *argp1 = 0 ;
48564 int res1 = 0 ;
48565 PyObject *swig_obj[1] ;
48566
48567 if (!args) SWIG_fail;
48568 swig_obj[0] = args;
48569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48572 }
48573 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48574 {
48575 PyThreadState* __tstate = wxPyBeginAllowThreads();
48576 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48577 wxPyEndAllowThreads(__tstate);
48578 if (PyErr_Occurred()) SWIG_fail;
48579 }
48580 {
48581 resultobj = wxPyMake_wxObject(result, (bool)0);
48582 }
48583 return resultobj;
48584 fail:
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48590 PyObject *resultobj = 0;
48591 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48592 wxButton *result = 0 ;
48593 void *argp1 = 0 ;
48594 int res1 = 0 ;
48595 PyObject *swig_obj[1] ;
48596
48597 if (!args) SWIG_fail;
48598 swig_obj[0] = args;
48599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48600 if (!SWIG_IsOK(res1)) {
48601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48602 }
48603 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48604 {
48605 PyThreadState* __tstate = wxPyBeginAllowThreads();
48606 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48607 wxPyEndAllowThreads(__tstate);
48608 if (PyErr_Occurred()) SWIG_fail;
48609 }
48610 {
48611 resultobj = wxPyMake_wxObject(result, (bool)0);
48612 }
48613 return resultobj;
48614 fail:
48615 return NULL;
48616 }
48617
48618
48619 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48620 PyObject *obj;
48621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48622 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48623 return SWIG_Py_Void();
48624 }
48625
48626 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48627 return SWIG_Python_InitShadowInstance(args);
48628 }
48629
48630 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48631 PyObject *resultobj = 0;
48632 int arg1 = (int) 0 ;
48633 int arg2 = (int) 0 ;
48634 wxGBPosition *result = 0 ;
48635 int val1 ;
48636 int ecode1 = 0 ;
48637 int val2 ;
48638 int ecode2 = 0 ;
48639 PyObject * obj0 = 0 ;
48640 PyObject * obj1 = 0 ;
48641 char * kwnames[] = {
48642 (char *) "row",(char *) "col", NULL
48643 };
48644
48645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48646 if (obj0) {
48647 ecode1 = SWIG_AsVal_int(obj0, &val1);
48648 if (!SWIG_IsOK(ecode1)) {
48649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48650 }
48651 arg1 = static_cast< int >(val1);
48652 }
48653 if (obj1) {
48654 ecode2 = SWIG_AsVal_int(obj1, &val2);
48655 if (!SWIG_IsOK(ecode2)) {
48656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48657 }
48658 arg2 = static_cast< int >(val2);
48659 }
48660 {
48661 PyThreadState* __tstate = wxPyBeginAllowThreads();
48662 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48663 wxPyEndAllowThreads(__tstate);
48664 if (PyErr_Occurred()) SWIG_fail;
48665 }
48666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48667 return resultobj;
48668 fail:
48669 return NULL;
48670 }
48671
48672
48673 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48674 PyObject *resultobj = 0;
48675 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48676 void *argp1 = 0 ;
48677 int res1 = 0 ;
48678 PyObject *swig_obj[1] ;
48679
48680 if (!args) SWIG_fail;
48681 swig_obj[0] = args;
48682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48683 if (!SWIG_IsOK(res1)) {
48684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48685 }
48686 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48687 {
48688 PyThreadState* __tstate = wxPyBeginAllowThreads();
48689 delete arg1;
48690
48691 wxPyEndAllowThreads(__tstate);
48692 if (PyErr_Occurred()) SWIG_fail;
48693 }
48694 resultobj = SWIG_Py_Void();
48695 return resultobj;
48696 fail:
48697 return NULL;
48698 }
48699
48700
48701 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48702 PyObject *resultobj = 0;
48703 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48704 int result;
48705 void *argp1 = 0 ;
48706 int res1 = 0 ;
48707 PyObject *swig_obj[1] ;
48708
48709 if (!args) SWIG_fail;
48710 swig_obj[0] = args;
48711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48712 if (!SWIG_IsOK(res1)) {
48713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48714 }
48715 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 result = (int)((wxGBPosition const *)arg1)->GetRow();
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 resultobj = SWIG_From_int(static_cast< int >(result));
48723 return resultobj;
48724 fail:
48725 return NULL;
48726 }
48727
48728
48729 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48730 PyObject *resultobj = 0;
48731 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48732 int result;
48733 void *argp1 = 0 ;
48734 int res1 = 0 ;
48735 PyObject *swig_obj[1] ;
48736
48737 if (!args) SWIG_fail;
48738 swig_obj[0] = args;
48739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48740 if (!SWIG_IsOK(res1)) {
48741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48742 }
48743 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48744 {
48745 PyThreadState* __tstate = wxPyBeginAllowThreads();
48746 result = (int)((wxGBPosition const *)arg1)->GetCol();
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_From_int(static_cast< int >(result));
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48758 PyObject *resultobj = 0;
48759 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48760 int arg2 ;
48761 void *argp1 = 0 ;
48762 int res1 = 0 ;
48763 int val2 ;
48764 int ecode2 = 0 ;
48765 PyObject * obj0 = 0 ;
48766 PyObject * obj1 = 0 ;
48767 char * kwnames[] = {
48768 (char *) "self",(char *) "row", NULL
48769 };
48770
48771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48773 if (!SWIG_IsOK(res1)) {
48774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48775 }
48776 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48777 ecode2 = SWIG_AsVal_int(obj1, &val2);
48778 if (!SWIG_IsOK(ecode2)) {
48779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48780 }
48781 arg2 = static_cast< int >(val2);
48782 {
48783 PyThreadState* __tstate = wxPyBeginAllowThreads();
48784 (arg1)->SetRow(arg2);
48785 wxPyEndAllowThreads(__tstate);
48786 if (PyErr_Occurred()) SWIG_fail;
48787 }
48788 resultobj = SWIG_Py_Void();
48789 return resultobj;
48790 fail:
48791 return NULL;
48792 }
48793
48794
48795 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48796 PyObject *resultobj = 0;
48797 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48798 int arg2 ;
48799 void *argp1 = 0 ;
48800 int res1 = 0 ;
48801 int val2 ;
48802 int ecode2 = 0 ;
48803 PyObject * obj0 = 0 ;
48804 PyObject * obj1 = 0 ;
48805 char * kwnames[] = {
48806 (char *) "self",(char *) "col", NULL
48807 };
48808
48809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48811 if (!SWIG_IsOK(res1)) {
48812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48813 }
48814 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48815 ecode2 = SWIG_AsVal_int(obj1, &val2);
48816 if (!SWIG_IsOK(ecode2)) {
48817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48818 }
48819 arg2 = static_cast< int >(val2);
48820 {
48821 PyThreadState* __tstate = wxPyBeginAllowThreads();
48822 (arg1)->SetCol(arg2);
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 resultobj = SWIG_Py_Void();
48827 return resultobj;
48828 fail:
48829 return NULL;
48830 }
48831
48832
48833 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48834 PyObject *resultobj = 0;
48835 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48836 PyObject *arg2 = (PyObject *) 0 ;
48837 bool result;
48838 void *argp1 = 0 ;
48839 int res1 = 0 ;
48840 PyObject * obj0 = 0 ;
48841 PyObject * obj1 = 0 ;
48842 char * kwnames[] = {
48843 (char *) "self",(char *) "other", NULL
48844 };
48845
48846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48848 if (!SWIG_IsOK(res1)) {
48849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48850 }
48851 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48852 arg2 = obj1;
48853 {
48854 result = (bool)wxGBPosition___eq__(arg1,arg2);
48855 if (PyErr_Occurred()) SWIG_fail;
48856 }
48857 {
48858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48859 }
48860 return resultobj;
48861 fail:
48862 return NULL;
48863 }
48864
48865
48866 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48867 PyObject *resultobj = 0;
48868 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48869 PyObject *arg2 = (PyObject *) 0 ;
48870 bool result;
48871 void *argp1 = 0 ;
48872 int res1 = 0 ;
48873 PyObject * obj0 = 0 ;
48874 PyObject * obj1 = 0 ;
48875 char * kwnames[] = {
48876 (char *) "self",(char *) "other", NULL
48877 };
48878
48879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48881 if (!SWIG_IsOK(res1)) {
48882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48883 }
48884 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48885 arg2 = obj1;
48886 {
48887 result = (bool)wxGBPosition___ne__(arg1,arg2);
48888 if (PyErr_Occurred()) SWIG_fail;
48889 }
48890 {
48891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48892 }
48893 return resultobj;
48894 fail:
48895 return NULL;
48896 }
48897
48898
48899 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48900 PyObject *resultobj = 0;
48901 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48902 int arg2 = (int) 0 ;
48903 int arg3 = (int) 0 ;
48904 void *argp1 = 0 ;
48905 int res1 = 0 ;
48906 int val2 ;
48907 int ecode2 = 0 ;
48908 int val3 ;
48909 int ecode3 = 0 ;
48910 PyObject * obj0 = 0 ;
48911 PyObject * obj1 = 0 ;
48912 PyObject * obj2 = 0 ;
48913 char * kwnames[] = {
48914 (char *) "self",(char *) "row",(char *) "col", NULL
48915 };
48916
48917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48919 if (!SWIG_IsOK(res1)) {
48920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48921 }
48922 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48923 if (obj1) {
48924 ecode2 = SWIG_AsVal_int(obj1, &val2);
48925 if (!SWIG_IsOK(ecode2)) {
48926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48927 }
48928 arg2 = static_cast< int >(val2);
48929 }
48930 if (obj2) {
48931 ecode3 = SWIG_AsVal_int(obj2, &val3);
48932 if (!SWIG_IsOK(ecode3)) {
48933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48934 }
48935 arg3 = static_cast< int >(val3);
48936 }
48937 {
48938 PyThreadState* __tstate = wxPyBeginAllowThreads();
48939 wxGBPosition_Set(arg1,arg2,arg3);
48940 wxPyEndAllowThreads(__tstate);
48941 if (PyErr_Occurred()) SWIG_fail;
48942 }
48943 resultobj = SWIG_Py_Void();
48944 return resultobj;
48945 fail:
48946 return NULL;
48947 }
48948
48949
48950 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48951 PyObject *resultobj = 0;
48952 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48953 PyObject *result = 0 ;
48954 void *argp1 = 0 ;
48955 int res1 = 0 ;
48956 PyObject *swig_obj[1] ;
48957
48958 if (!args) SWIG_fail;
48959 swig_obj[0] = args;
48960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48961 if (!SWIG_IsOK(res1)) {
48962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48963 }
48964 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48965 {
48966 PyThreadState* __tstate = wxPyBeginAllowThreads();
48967 result = (PyObject *)wxGBPosition_Get(arg1);
48968 wxPyEndAllowThreads(__tstate);
48969 if (PyErr_Occurred()) SWIG_fail;
48970 }
48971 resultobj = result;
48972 return resultobj;
48973 fail:
48974 return NULL;
48975 }
48976
48977
48978 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48979 PyObject *obj;
48980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48981 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48982 return SWIG_Py_Void();
48983 }
48984
48985 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48986 return SWIG_Python_InitShadowInstance(args);
48987 }
48988
48989 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48990 PyObject *resultobj = 0;
48991 int arg1 = (int) 1 ;
48992 int arg2 = (int) 1 ;
48993 wxGBSpan *result = 0 ;
48994 int val1 ;
48995 int ecode1 = 0 ;
48996 int val2 ;
48997 int ecode2 = 0 ;
48998 PyObject * obj0 = 0 ;
48999 PyObject * obj1 = 0 ;
49000 char * kwnames[] = {
49001 (char *) "rowspan",(char *) "colspan", NULL
49002 };
49003
49004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49005 if (obj0) {
49006 ecode1 = SWIG_AsVal_int(obj0, &val1);
49007 if (!SWIG_IsOK(ecode1)) {
49008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49009 }
49010 arg1 = static_cast< int >(val1);
49011 }
49012 if (obj1) {
49013 ecode2 = SWIG_AsVal_int(obj1, &val2);
49014 if (!SWIG_IsOK(ecode2)) {
49015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49016 }
49017 arg2 = static_cast< int >(val2);
49018 }
49019 {
49020 PyThreadState* __tstate = wxPyBeginAllowThreads();
49021 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49022 wxPyEndAllowThreads(__tstate);
49023 if (PyErr_Occurred()) SWIG_fail;
49024 }
49025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49026 return resultobj;
49027 fail:
49028 return NULL;
49029 }
49030
49031
49032 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49033 PyObject *resultobj = 0;
49034 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49035 void *argp1 = 0 ;
49036 int res1 = 0 ;
49037 PyObject *swig_obj[1] ;
49038
49039 if (!args) SWIG_fail;
49040 swig_obj[0] = args;
49041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49042 if (!SWIG_IsOK(res1)) {
49043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49044 }
49045 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49046 {
49047 PyThreadState* __tstate = wxPyBeginAllowThreads();
49048 delete arg1;
49049
49050 wxPyEndAllowThreads(__tstate);
49051 if (PyErr_Occurred()) SWIG_fail;
49052 }
49053 resultobj = SWIG_Py_Void();
49054 return resultobj;
49055 fail:
49056 return NULL;
49057 }
49058
49059
49060 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49061 PyObject *resultobj = 0;
49062 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49063 int result;
49064 void *argp1 = 0 ;
49065 int res1 = 0 ;
49066 PyObject *swig_obj[1] ;
49067
49068 if (!args) SWIG_fail;
49069 swig_obj[0] = args;
49070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49071 if (!SWIG_IsOK(res1)) {
49072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49073 }
49074 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49075 {
49076 PyThreadState* __tstate = wxPyBeginAllowThreads();
49077 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49078 wxPyEndAllowThreads(__tstate);
49079 if (PyErr_Occurred()) SWIG_fail;
49080 }
49081 resultobj = SWIG_From_int(static_cast< int >(result));
49082 return resultobj;
49083 fail:
49084 return NULL;
49085 }
49086
49087
49088 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49089 PyObject *resultobj = 0;
49090 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49091 int result;
49092 void *argp1 = 0 ;
49093 int res1 = 0 ;
49094 PyObject *swig_obj[1] ;
49095
49096 if (!args) SWIG_fail;
49097 swig_obj[0] = args;
49098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49099 if (!SWIG_IsOK(res1)) {
49100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49101 }
49102 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49103 {
49104 PyThreadState* __tstate = wxPyBeginAllowThreads();
49105 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 resultobj = SWIG_From_int(static_cast< int >(result));
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49117 PyObject *resultobj = 0;
49118 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49119 int arg2 ;
49120 void *argp1 = 0 ;
49121 int res1 = 0 ;
49122 int val2 ;
49123 int ecode2 = 0 ;
49124 PyObject * obj0 = 0 ;
49125 PyObject * obj1 = 0 ;
49126 char * kwnames[] = {
49127 (char *) "self",(char *) "rowspan", NULL
49128 };
49129
49130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49132 if (!SWIG_IsOK(res1)) {
49133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49134 }
49135 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49136 ecode2 = SWIG_AsVal_int(obj1, &val2);
49137 if (!SWIG_IsOK(ecode2)) {
49138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49139 }
49140 arg2 = static_cast< int >(val2);
49141 {
49142 PyThreadState* __tstate = wxPyBeginAllowThreads();
49143 (arg1)->SetRowspan(arg2);
49144 wxPyEndAllowThreads(__tstate);
49145 if (PyErr_Occurred()) SWIG_fail;
49146 }
49147 resultobj = SWIG_Py_Void();
49148 return resultobj;
49149 fail:
49150 return NULL;
49151 }
49152
49153
49154 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49155 PyObject *resultobj = 0;
49156 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49157 int arg2 ;
49158 void *argp1 = 0 ;
49159 int res1 = 0 ;
49160 int val2 ;
49161 int ecode2 = 0 ;
49162 PyObject * obj0 = 0 ;
49163 PyObject * obj1 = 0 ;
49164 char * kwnames[] = {
49165 (char *) "self",(char *) "colspan", NULL
49166 };
49167
49168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49170 if (!SWIG_IsOK(res1)) {
49171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49172 }
49173 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49174 ecode2 = SWIG_AsVal_int(obj1, &val2);
49175 if (!SWIG_IsOK(ecode2)) {
49176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49177 }
49178 arg2 = static_cast< int >(val2);
49179 {
49180 PyThreadState* __tstate = wxPyBeginAllowThreads();
49181 (arg1)->SetColspan(arg2);
49182 wxPyEndAllowThreads(__tstate);
49183 if (PyErr_Occurred()) SWIG_fail;
49184 }
49185 resultobj = SWIG_Py_Void();
49186 return resultobj;
49187 fail:
49188 return NULL;
49189 }
49190
49191
49192 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49193 PyObject *resultobj = 0;
49194 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49195 PyObject *arg2 = (PyObject *) 0 ;
49196 bool result;
49197 void *argp1 = 0 ;
49198 int res1 = 0 ;
49199 PyObject * obj0 = 0 ;
49200 PyObject * obj1 = 0 ;
49201 char * kwnames[] = {
49202 (char *) "self",(char *) "other", NULL
49203 };
49204
49205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49207 if (!SWIG_IsOK(res1)) {
49208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49209 }
49210 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49211 arg2 = obj1;
49212 {
49213 result = (bool)wxGBSpan___eq__(arg1,arg2);
49214 if (PyErr_Occurred()) SWIG_fail;
49215 }
49216 {
49217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49218 }
49219 return resultobj;
49220 fail:
49221 return NULL;
49222 }
49223
49224
49225 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49226 PyObject *resultobj = 0;
49227 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49228 PyObject *arg2 = (PyObject *) 0 ;
49229 bool result;
49230 void *argp1 = 0 ;
49231 int res1 = 0 ;
49232 PyObject * obj0 = 0 ;
49233 PyObject * obj1 = 0 ;
49234 char * kwnames[] = {
49235 (char *) "self",(char *) "other", NULL
49236 };
49237
49238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49240 if (!SWIG_IsOK(res1)) {
49241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49242 }
49243 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49244 arg2 = obj1;
49245 {
49246 result = (bool)wxGBSpan___ne__(arg1,arg2);
49247 if (PyErr_Occurred()) SWIG_fail;
49248 }
49249 {
49250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49251 }
49252 return resultobj;
49253 fail:
49254 return NULL;
49255 }
49256
49257
49258 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49259 PyObject *resultobj = 0;
49260 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49261 int arg2 = (int) 1 ;
49262 int arg3 = (int) 1 ;
49263 void *argp1 = 0 ;
49264 int res1 = 0 ;
49265 int val2 ;
49266 int ecode2 = 0 ;
49267 int val3 ;
49268 int ecode3 = 0 ;
49269 PyObject * obj0 = 0 ;
49270 PyObject * obj1 = 0 ;
49271 PyObject * obj2 = 0 ;
49272 char * kwnames[] = {
49273 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49274 };
49275
49276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49278 if (!SWIG_IsOK(res1)) {
49279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49280 }
49281 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49282 if (obj1) {
49283 ecode2 = SWIG_AsVal_int(obj1, &val2);
49284 if (!SWIG_IsOK(ecode2)) {
49285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49286 }
49287 arg2 = static_cast< int >(val2);
49288 }
49289 if (obj2) {
49290 ecode3 = SWIG_AsVal_int(obj2, &val3);
49291 if (!SWIG_IsOK(ecode3)) {
49292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49293 }
49294 arg3 = static_cast< int >(val3);
49295 }
49296 {
49297 PyThreadState* __tstate = wxPyBeginAllowThreads();
49298 wxGBSpan_Set(arg1,arg2,arg3);
49299 wxPyEndAllowThreads(__tstate);
49300 if (PyErr_Occurred()) SWIG_fail;
49301 }
49302 resultobj = SWIG_Py_Void();
49303 return resultobj;
49304 fail:
49305 return NULL;
49306 }
49307
49308
49309 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49310 PyObject *resultobj = 0;
49311 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49312 PyObject *result = 0 ;
49313 void *argp1 = 0 ;
49314 int res1 = 0 ;
49315 PyObject *swig_obj[1] ;
49316
49317 if (!args) SWIG_fail;
49318 swig_obj[0] = args;
49319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49320 if (!SWIG_IsOK(res1)) {
49321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49322 }
49323 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49324 {
49325 PyThreadState* __tstate = wxPyBeginAllowThreads();
49326 result = (PyObject *)wxGBSpan_Get(arg1);
49327 wxPyEndAllowThreads(__tstate);
49328 if (PyErr_Occurred()) SWIG_fail;
49329 }
49330 resultobj = result;
49331 return resultobj;
49332 fail:
49333 return NULL;
49334 }
49335
49336
49337 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49338 PyObject *obj;
49339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49340 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49341 return SWIG_Py_Void();
49342 }
49343
49344 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49345 return SWIG_Python_InitShadowInstance(args);
49346 }
49347
49348 SWIGINTERN int DefaultSpan_set(PyObject *) {
49349 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49350 return 1;
49351 }
49352
49353
49354 SWIGINTERN PyObject *DefaultSpan_get(void) {
49355 PyObject *pyobj = 0;
49356
49357 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49358 return pyobj;
49359 }
49360
49361
49362 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49363 PyObject *resultobj = 0;
49364 wxGBSizerItem *result = 0 ;
49365
49366 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49367 {
49368 PyThreadState* __tstate = wxPyBeginAllowThreads();
49369 result = (wxGBSizerItem *)new wxGBSizerItem();
49370 wxPyEndAllowThreads(__tstate);
49371 if (PyErr_Occurred()) SWIG_fail;
49372 }
49373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49374 return resultobj;
49375 fail:
49376 return NULL;
49377 }
49378
49379
49380 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49381 PyObject *resultobj = 0;
49382 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49383 void *argp1 = 0 ;
49384 int res1 = 0 ;
49385 PyObject *swig_obj[1] ;
49386
49387 if (!args) SWIG_fail;
49388 swig_obj[0] = args;
49389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49390 if (!SWIG_IsOK(res1)) {
49391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49392 }
49393 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 delete arg1;
49397
49398 wxPyEndAllowThreads(__tstate);
49399 if (PyErr_Occurred()) SWIG_fail;
49400 }
49401 resultobj = SWIG_Py_Void();
49402 return resultobj;
49403 fail:
49404 return NULL;
49405 }
49406
49407
49408 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49409 PyObject *resultobj = 0;
49410 wxWindow *arg1 = (wxWindow *) 0 ;
49411 wxGBPosition *arg2 = 0 ;
49412 wxGBSpan *arg3 = 0 ;
49413 int arg4 ;
49414 int arg5 ;
49415 PyObject *arg6 = (PyObject *) NULL ;
49416 wxGBSizerItem *result = 0 ;
49417 void *argp1 = 0 ;
49418 int res1 = 0 ;
49419 wxGBPosition temp2 ;
49420 wxGBSpan temp3 ;
49421 int val4 ;
49422 int ecode4 = 0 ;
49423 int val5 ;
49424 int ecode5 = 0 ;
49425 PyObject * obj0 = 0 ;
49426 PyObject * obj1 = 0 ;
49427 PyObject * obj2 = 0 ;
49428 PyObject * obj3 = 0 ;
49429 PyObject * obj4 = 0 ;
49430 PyObject * obj5 = 0 ;
49431 char * kwnames[] = {
49432 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49433 };
49434
49435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49437 if (!SWIG_IsOK(res1)) {
49438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49439 }
49440 arg1 = reinterpret_cast< wxWindow * >(argp1);
49441 {
49442 arg2 = &temp2;
49443 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49444 }
49445 {
49446 arg3 = &temp3;
49447 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49448 }
49449 ecode4 = SWIG_AsVal_int(obj3, &val4);
49450 if (!SWIG_IsOK(ecode4)) {
49451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49452 }
49453 arg4 = static_cast< int >(val4);
49454 ecode5 = SWIG_AsVal_int(obj4, &val5);
49455 if (!SWIG_IsOK(ecode5)) {
49456 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49457 }
49458 arg5 = static_cast< int >(val5);
49459 if (obj5) {
49460 arg6 = obj5;
49461 }
49462 {
49463 PyThreadState* __tstate = wxPyBeginAllowThreads();
49464 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49465 wxPyEndAllowThreads(__tstate);
49466 if (PyErr_Occurred()) SWIG_fail;
49467 }
49468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49469 return resultobj;
49470 fail:
49471 return NULL;
49472 }
49473
49474
49475 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49476 PyObject *resultobj = 0;
49477 wxSizer *arg1 = (wxSizer *) 0 ;
49478 wxGBPosition *arg2 = 0 ;
49479 wxGBSpan *arg3 = 0 ;
49480 int arg4 ;
49481 int arg5 ;
49482 PyObject *arg6 = (PyObject *) NULL ;
49483 wxGBSizerItem *result = 0 ;
49484 int res1 = 0 ;
49485 wxGBPosition temp2 ;
49486 wxGBSpan temp3 ;
49487 int val4 ;
49488 int ecode4 = 0 ;
49489 int val5 ;
49490 int ecode5 = 0 ;
49491 PyObject * obj0 = 0 ;
49492 PyObject * obj1 = 0 ;
49493 PyObject * obj2 = 0 ;
49494 PyObject * obj3 = 0 ;
49495 PyObject * obj4 = 0 ;
49496 PyObject * obj5 = 0 ;
49497 char * kwnames[] = {
49498 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49499 };
49500
49501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49502 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49503 if (!SWIG_IsOK(res1)) {
49504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49505 }
49506 {
49507 arg2 = &temp2;
49508 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49509 }
49510 {
49511 arg3 = &temp3;
49512 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49513 }
49514 ecode4 = SWIG_AsVal_int(obj3, &val4);
49515 if (!SWIG_IsOK(ecode4)) {
49516 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49517 }
49518 arg4 = static_cast< int >(val4);
49519 ecode5 = SWIG_AsVal_int(obj4, &val5);
49520 if (!SWIG_IsOK(ecode5)) {
49521 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49522 }
49523 arg5 = static_cast< int >(val5);
49524 if (obj5) {
49525 arg6 = obj5;
49526 }
49527 {
49528 PyThreadState* __tstate = wxPyBeginAllowThreads();
49529 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49530 wxPyEndAllowThreads(__tstate);
49531 if (PyErr_Occurred()) SWIG_fail;
49532 }
49533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49534 return resultobj;
49535 fail:
49536 return NULL;
49537 }
49538
49539
49540 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49541 PyObject *resultobj = 0;
49542 int arg1 ;
49543 int arg2 ;
49544 wxGBPosition *arg3 = 0 ;
49545 wxGBSpan *arg4 = 0 ;
49546 int arg5 ;
49547 int arg6 ;
49548 PyObject *arg7 = (PyObject *) NULL ;
49549 wxGBSizerItem *result = 0 ;
49550 int val1 ;
49551 int ecode1 = 0 ;
49552 int val2 ;
49553 int ecode2 = 0 ;
49554 wxGBPosition temp3 ;
49555 wxGBSpan temp4 ;
49556 int val5 ;
49557 int ecode5 = 0 ;
49558 int val6 ;
49559 int ecode6 = 0 ;
49560 PyObject * obj0 = 0 ;
49561 PyObject * obj1 = 0 ;
49562 PyObject * obj2 = 0 ;
49563 PyObject * obj3 = 0 ;
49564 PyObject * obj4 = 0 ;
49565 PyObject * obj5 = 0 ;
49566 PyObject * obj6 = 0 ;
49567 char * kwnames[] = {
49568 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49569 };
49570
49571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49572 ecode1 = SWIG_AsVal_int(obj0, &val1);
49573 if (!SWIG_IsOK(ecode1)) {
49574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49575 }
49576 arg1 = static_cast< int >(val1);
49577 ecode2 = SWIG_AsVal_int(obj1, &val2);
49578 if (!SWIG_IsOK(ecode2)) {
49579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49580 }
49581 arg2 = static_cast< int >(val2);
49582 {
49583 arg3 = &temp3;
49584 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49585 }
49586 {
49587 arg4 = &temp4;
49588 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49589 }
49590 ecode5 = SWIG_AsVal_int(obj4, &val5);
49591 if (!SWIG_IsOK(ecode5)) {
49592 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49593 }
49594 arg5 = static_cast< int >(val5);
49595 ecode6 = SWIG_AsVal_int(obj5, &val6);
49596 if (!SWIG_IsOK(ecode6)) {
49597 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49598 }
49599 arg6 = static_cast< int >(val6);
49600 if (obj6) {
49601 arg7 = obj6;
49602 }
49603 {
49604 PyThreadState* __tstate = wxPyBeginAllowThreads();
49605 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49606 wxPyEndAllowThreads(__tstate);
49607 if (PyErr_Occurred()) SWIG_fail;
49608 }
49609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49610 return resultobj;
49611 fail:
49612 return NULL;
49613 }
49614
49615
49616 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49617 PyObject *resultobj = 0;
49618 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49619 wxGBPosition result;
49620 void *argp1 = 0 ;
49621 int res1 = 0 ;
49622 PyObject *swig_obj[1] ;
49623
49624 if (!args) SWIG_fail;
49625 swig_obj[0] = args;
49626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49627 if (!SWIG_IsOK(res1)) {
49628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49629 }
49630 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49631 {
49632 PyThreadState* __tstate = wxPyBeginAllowThreads();
49633 result = ((wxGBSizerItem const *)arg1)->GetPos();
49634 wxPyEndAllowThreads(__tstate);
49635 if (PyErr_Occurred()) SWIG_fail;
49636 }
49637 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49638 return resultobj;
49639 fail:
49640 return NULL;
49641 }
49642
49643
49644 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49645 PyObject *resultobj = 0;
49646 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49647 wxGBSpan result;
49648 void *argp1 = 0 ;
49649 int res1 = 0 ;
49650 PyObject *swig_obj[1] ;
49651
49652 if (!args) SWIG_fail;
49653 swig_obj[0] = args;
49654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49655 if (!SWIG_IsOK(res1)) {
49656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49657 }
49658 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49659 {
49660 PyThreadState* __tstate = wxPyBeginAllowThreads();
49661 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49662 wxPyEndAllowThreads(__tstate);
49663 if (PyErr_Occurred()) SWIG_fail;
49664 }
49665 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49666 return resultobj;
49667 fail:
49668 return NULL;
49669 }
49670
49671
49672 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49673 PyObject *resultobj = 0;
49674 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49675 wxGBPosition *arg2 = 0 ;
49676 bool result;
49677 void *argp1 = 0 ;
49678 int res1 = 0 ;
49679 wxGBPosition temp2 ;
49680 PyObject * obj0 = 0 ;
49681 PyObject * obj1 = 0 ;
49682 char * kwnames[] = {
49683 (char *) "self",(char *) "pos", NULL
49684 };
49685
49686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49688 if (!SWIG_IsOK(res1)) {
49689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49690 }
49691 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49692 {
49693 arg2 = &temp2;
49694 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49695 }
49696 {
49697 PyThreadState* __tstate = wxPyBeginAllowThreads();
49698 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49699 wxPyEndAllowThreads(__tstate);
49700 if (PyErr_Occurred()) SWIG_fail;
49701 }
49702 {
49703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49704 }
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49712 PyObject *resultobj = 0;
49713 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49714 wxGBSpan *arg2 = 0 ;
49715 bool result;
49716 void *argp1 = 0 ;
49717 int res1 = 0 ;
49718 wxGBSpan temp2 ;
49719 PyObject * obj0 = 0 ;
49720 PyObject * obj1 = 0 ;
49721 char * kwnames[] = {
49722 (char *) "self",(char *) "span", NULL
49723 };
49724
49725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49727 if (!SWIG_IsOK(res1)) {
49728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49729 }
49730 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49731 {
49732 arg2 = &temp2;
49733 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49734 }
49735 {
49736 PyThreadState* __tstate = wxPyBeginAllowThreads();
49737 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49738 wxPyEndAllowThreads(__tstate);
49739 if (PyErr_Occurred()) SWIG_fail;
49740 }
49741 {
49742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49743 }
49744 return resultobj;
49745 fail:
49746 return NULL;
49747 }
49748
49749
49750 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49751 PyObject *resultobj = 0;
49752 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49753 wxGBSizerItem *arg2 = 0 ;
49754 bool result;
49755 void *argp1 = 0 ;
49756 int res1 = 0 ;
49757 void *argp2 = 0 ;
49758 int res2 = 0 ;
49759 PyObject * obj0 = 0 ;
49760 PyObject * obj1 = 0 ;
49761 char * kwnames[] = {
49762 (char *) "self",(char *) "other", NULL
49763 };
49764
49765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49767 if (!SWIG_IsOK(res1)) {
49768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49769 }
49770 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49771 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49772 if (!SWIG_IsOK(res2)) {
49773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49774 }
49775 if (!argp2) {
49776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49777 }
49778 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49779 {
49780 PyThreadState* __tstate = wxPyBeginAllowThreads();
49781 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 {
49786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49787 }
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49795 PyObject *resultobj = 0;
49796 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49797 wxGBPosition *arg2 = 0 ;
49798 wxGBSpan *arg3 = 0 ;
49799 bool result;
49800 void *argp1 = 0 ;
49801 int res1 = 0 ;
49802 wxGBPosition temp2 ;
49803 wxGBSpan temp3 ;
49804 PyObject * obj0 = 0 ;
49805 PyObject * obj1 = 0 ;
49806 PyObject * obj2 = 0 ;
49807 char * kwnames[] = {
49808 (char *) "self",(char *) "pos",(char *) "span", NULL
49809 };
49810
49811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49813 if (!SWIG_IsOK(res1)) {
49814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49815 }
49816 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49817 {
49818 arg2 = &temp2;
49819 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49820 }
49821 {
49822 arg3 = &temp3;
49823 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49824 }
49825 {
49826 PyThreadState* __tstate = wxPyBeginAllowThreads();
49827 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49828 wxPyEndAllowThreads(__tstate);
49829 if (PyErr_Occurred()) SWIG_fail;
49830 }
49831 {
49832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49833 }
49834 return resultobj;
49835 fail:
49836 return NULL;
49837 }
49838
49839
49840 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49841 PyObject *resultobj = 0;
49842 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49843 wxGBPosition result;
49844 void *argp1 = 0 ;
49845 int res1 = 0 ;
49846 PyObject *swig_obj[1] ;
49847
49848 if (!args) SWIG_fail;
49849 swig_obj[0] = args;
49850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49851 if (!SWIG_IsOK(res1)) {
49852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49853 }
49854 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49855 {
49856 PyThreadState* __tstate = wxPyBeginAllowThreads();
49857 result = wxGBSizerItem_GetEndPos(arg1);
49858 wxPyEndAllowThreads(__tstate);
49859 if (PyErr_Occurred()) SWIG_fail;
49860 }
49861 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49862 return resultobj;
49863 fail:
49864 return NULL;
49865 }
49866
49867
49868 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49869 PyObject *resultobj = 0;
49870 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49871 wxGridBagSizer *result = 0 ;
49872 void *argp1 = 0 ;
49873 int res1 = 0 ;
49874 PyObject *swig_obj[1] ;
49875
49876 if (!args) SWIG_fail;
49877 swig_obj[0] = args;
49878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49879 if (!SWIG_IsOK(res1)) {
49880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49881 }
49882 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49883 {
49884 PyThreadState* __tstate = wxPyBeginAllowThreads();
49885 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49886 wxPyEndAllowThreads(__tstate);
49887 if (PyErr_Occurred()) SWIG_fail;
49888 }
49889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49890 return resultobj;
49891 fail:
49892 return NULL;
49893 }
49894
49895
49896 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49897 PyObject *resultobj = 0;
49898 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49899 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49900 void *argp1 = 0 ;
49901 int res1 = 0 ;
49902 void *argp2 = 0 ;
49903 int res2 = 0 ;
49904 PyObject * obj0 = 0 ;
49905 PyObject * obj1 = 0 ;
49906 char * kwnames[] = {
49907 (char *) "self",(char *) "sizer", NULL
49908 };
49909
49910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49912 if (!SWIG_IsOK(res1)) {
49913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49914 }
49915 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49916 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49917 if (!SWIG_IsOK(res2)) {
49918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49919 }
49920 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49921 {
49922 PyThreadState* __tstate = wxPyBeginAllowThreads();
49923 (arg1)->SetGBSizer(arg2);
49924 wxPyEndAllowThreads(__tstate);
49925 if (PyErr_Occurred()) SWIG_fail;
49926 }
49927 resultobj = SWIG_Py_Void();
49928 return resultobj;
49929 fail:
49930 return NULL;
49931 }
49932
49933
49934 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49935 PyObject *obj;
49936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49937 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49938 return SWIG_Py_Void();
49939 }
49940
49941 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49942 return SWIG_Python_InitShadowInstance(args);
49943 }
49944
49945 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49946 PyObject *resultobj = 0;
49947 int arg1 = (int) 0 ;
49948 int arg2 = (int) 0 ;
49949 wxGridBagSizer *result = 0 ;
49950 int val1 ;
49951 int ecode1 = 0 ;
49952 int val2 ;
49953 int ecode2 = 0 ;
49954 PyObject * obj0 = 0 ;
49955 PyObject * obj1 = 0 ;
49956 char * kwnames[] = {
49957 (char *) "vgap",(char *) "hgap", NULL
49958 };
49959
49960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49961 if (obj0) {
49962 ecode1 = SWIG_AsVal_int(obj0, &val1);
49963 if (!SWIG_IsOK(ecode1)) {
49964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49965 }
49966 arg1 = static_cast< int >(val1);
49967 }
49968 if (obj1) {
49969 ecode2 = SWIG_AsVal_int(obj1, &val2);
49970 if (!SWIG_IsOK(ecode2)) {
49971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49972 }
49973 arg2 = static_cast< int >(val2);
49974 }
49975 {
49976 PyThreadState* __tstate = wxPyBeginAllowThreads();
49977 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49978 wxPyEndAllowThreads(__tstate);
49979 if (PyErr_Occurred()) SWIG_fail;
49980 }
49981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49982 return resultobj;
49983 fail:
49984 return NULL;
49985 }
49986
49987
49988 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49989 PyObject *resultobj = 0;
49990 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49991 PyObject *arg2 = (PyObject *) 0 ;
49992 wxGBPosition *arg3 = 0 ;
49993 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49994 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49995 int arg5 = (int) 0 ;
49996 int arg6 = (int) 0 ;
49997 PyObject *arg7 = (PyObject *) NULL ;
49998 wxGBSizerItem *result = 0 ;
49999 void *argp1 = 0 ;
50000 int res1 = 0 ;
50001 wxGBPosition temp3 ;
50002 wxGBSpan temp4 ;
50003 int val5 ;
50004 int ecode5 = 0 ;
50005 int val6 ;
50006 int ecode6 = 0 ;
50007 PyObject * obj0 = 0 ;
50008 PyObject * obj1 = 0 ;
50009 PyObject * obj2 = 0 ;
50010 PyObject * obj3 = 0 ;
50011 PyObject * obj4 = 0 ;
50012 PyObject * obj5 = 0 ;
50013 PyObject * obj6 = 0 ;
50014 char * kwnames[] = {
50015 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50016 };
50017
50018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50020 if (!SWIG_IsOK(res1)) {
50021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50022 }
50023 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50024 arg2 = obj1;
50025 {
50026 arg3 = &temp3;
50027 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50028 }
50029 if (obj3) {
50030 {
50031 arg4 = &temp4;
50032 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50033 }
50034 }
50035 if (obj4) {
50036 ecode5 = SWIG_AsVal_int(obj4, &val5);
50037 if (!SWIG_IsOK(ecode5)) {
50038 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50039 }
50040 arg5 = static_cast< int >(val5);
50041 }
50042 if (obj5) {
50043 ecode6 = SWIG_AsVal_int(obj5, &val6);
50044 if (!SWIG_IsOK(ecode6)) {
50045 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50046 }
50047 arg6 = static_cast< int >(val6);
50048 }
50049 if (obj6) {
50050 arg7 = obj6;
50051 }
50052 {
50053 PyThreadState* __tstate = wxPyBeginAllowThreads();
50054 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50055 wxPyEndAllowThreads(__tstate);
50056 if (PyErr_Occurred()) SWIG_fail;
50057 }
50058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50059 return resultobj;
50060 fail:
50061 return NULL;
50062 }
50063
50064
50065 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50066 PyObject *resultobj = 0;
50067 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50068 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50069 wxGBSizerItem *result = 0 ;
50070 void *argp1 = 0 ;
50071 int res1 = 0 ;
50072 int res2 = 0 ;
50073 PyObject * obj0 = 0 ;
50074 PyObject * obj1 = 0 ;
50075 char * kwnames[] = {
50076 (char *) "self",(char *) "item", NULL
50077 };
50078
50079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50081 if (!SWIG_IsOK(res1)) {
50082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50083 }
50084 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50085 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50086 if (!SWIG_IsOK(res2)) {
50087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50088 }
50089 {
50090 PyThreadState* __tstate = wxPyBeginAllowThreads();
50091 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50092 wxPyEndAllowThreads(__tstate);
50093 if (PyErr_Occurred()) SWIG_fail;
50094 }
50095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50105 int arg2 ;
50106 int arg3 ;
50107 wxSize result;
50108 void *argp1 = 0 ;
50109 int res1 = 0 ;
50110 int val2 ;
50111 int ecode2 = 0 ;
50112 int val3 ;
50113 int ecode3 = 0 ;
50114 PyObject * obj0 = 0 ;
50115 PyObject * obj1 = 0 ;
50116 PyObject * obj2 = 0 ;
50117 char * kwnames[] = {
50118 (char *) "self",(char *) "row",(char *) "col", NULL
50119 };
50120
50121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50123 if (!SWIG_IsOK(res1)) {
50124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50125 }
50126 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50127 ecode2 = SWIG_AsVal_int(obj1, &val2);
50128 if (!SWIG_IsOK(ecode2)) {
50129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50130 }
50131 arg2 = static_cast< int >(val2);
50132 ecode3 = SWIG_AsVal_int(obj2, &val3);
50133 if (!SWIG_IsOK(ecode3)) {
50134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50135 }
50136 arg3 = static_cast< int >(val3);
50137 {
50138 PyThreadState* __tstate = wxPyBeginAllowThreads();
50139 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50140 wxPyEndAllowThreads(__tstate);
50141 if (PyErr_Occurred()) SWIG_fail;
50142 }
50143 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50144 return resultobj;
50145 fail:
50146 return NULL;
50147 }
50148
50149
50150 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50151 PyObject *resultobj = 0;
50152 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50153 wxSize result;
50154 void *argp1 = 0 ;
50155 int res1 = 0 ;
50156 PyObject *swig_obj[1] ;
50157
50158 if (!args) SWIG_fail;
50159 swig_obj[0] = args;
50160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50161 if (!SWIG_IsOK(res1)) {
50162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50163 }
50164 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50165 {
50166 PyThreadState* __tstate = wxPyBeginAllowThreads();
50167 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50168 wxPyEndAllowThreads(__tstate);
50169 if (PyErr_Occurred()) SWIG_fail;
50170 }
50171 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50172 return resultobj;
50173 fail:
50174 return NULL;
50175 }
50176
50177
50178 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50179 PyObject *resultobj = 0;
50180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50181 wxSize *arg2 = 0 ;
50182 void *argp1 = 0 ;
50183 int res1 = 0 ;
50184 wxSize temp2 ;
50185 PyObject * obj0 = 0 ;
50186 PyObject * obj1 = 0 ;
50187 char * kwnames[] = {
50188 (char *) "self",(char *) "sz", NULL
50189 };
50190
50191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50193 if (!SWIG_IsOK(res1)) {
50194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50195 }
50196 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50197 {
50198 arg2 = &temp2;
50199 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50200 }
50201 {
50202 PyThreadState* __tstate = wxPyBeginAllowThreads();
50203 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50204 wxPyEndAllowThreads(__tstate);
50205 if (PyErr_Occurred()) SWIG_fail;
50206 }
50207 resultobj = SWIG_Py_Void();
50208 return resultobj;
50209 fail:
50210 return NULL;
50211 }
50212
50213
50214 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50215 PyObject *resultobj = 0;
50216 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50217 wxWindow *arg2 = (wxWindow *) 0 ;
50218 wxGBPosition result;
50219 void *argp1 = 0 ;
50220 int res1 = 0 ;
50221 void *argp2 = 0 ;
50222 int res2 = 0 ;
50223
50224 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50226 if (!SWIG_IsOK(res1)) {
50227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50228 }
50229 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50230 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50231 if (!SWIG_IsOK(res2)) {
50232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50233 }
50234 arg2 = reinterpret_cast< wxWindow * >(argp2);
50235 {
50236 PyThreadState* __tstate = wxPyBeginAllowThreads();
50237 result = (arg1)->GetItemPosition(arg2);
50238 wxPyEndAllowThreads(__tstate);
50239 if (PyErr_Occurred()) SWIG_fail;
50240 }
50241 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50242 return resultobj;
50243 fail:
50244 return NULL;
50245 }
50246
50247
50248 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50249 PyObject *resultobj = 0;
50250 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50251 wxSizer *arg2 = (wxSizer *) 0 ;
50252 wxGBPosition result;
50253 void *argp1 = 0 ;
50254 int res1 = 0 ;
50255 void *argp2 = 0 ;
50256 int res2 = 0 ;
50257
50258 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50260 if (!SWIG_IsOK(res1)) {
50261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50262 }
50263 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50264 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50265 if (!SWIG_IsOK(res2)) {
50266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50267 }
50268 arg2 = reinterpret_cast< wxSizer * >(argp2);
50269 {
50270 PyThreadState* __tstate = wxPyBeginAllowThreads();
50271 result = (arg1)->GetItemPosition(arg2);
50272 wxPyEndAllowThreads(__tstate);
50273 if (PyErr_Occurred()) SWIG_fail;
50274 }
50275 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50276 return resultobj;
50277 fail:
50278 return NULL;
50279 }
50280
50281
50282 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50283 PyObject *resultobj = 0;
50284 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50285 size_t arg2 ;
50286 wxGBPosition result;
50287 void *argp1 = 0 ;
50288 int res1 = 0 ;
50289 size_t val2 ;
50290 int ecode2 = 0 ;
50291
50292 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50294 if (!SWIG_IsOK(res1)) {
50295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50296 }
50297 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50298 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50299 if (!SWIG_IsOK(ecode2)) {
50300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50301 }
50302 arg2 = static_cast< size_t >(val2);
50303 {
50304 PyThreadState* __tstate = wxPyBeginAllowThreads();
50305 result = (arg1)->GetItemPosition(arg2);
50306 wxPyEndAllowThreads(__tstate);
50307 if (PyErr_Occurred()) SWIG_fail;
50308 }
50309 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50310 return resultobj;
50311 fail:
50312 return NULL;
50313 }
50314
50315
50316 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50317 int argc;
50318 PyObject *argv[3];
50319
50320 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50321 --argc;
50322 if (argc == 2) {
50323 int _v = 0;
50324 {
50325 void *vptr = 0;
50326 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50327 _v = SWIG_CheckState(res);
50328 }
50329 if (!_v) goto check_1;
50330 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50331 }
50332 check_1:
50333
50334 if (argc == 2) {
50335 int _v = 0;
50336 {
50337 void *vptr = 0;
50338 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50339 _v = SWIG_CheckState(res);
50340 }
50341 if (!_v) goto check_2;
50342 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50343 }
50344 check_2:
50345
50346 if (argc == 2) {
50347 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50348 }
50349
50350 fail:
50351 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50352 return NULL;
50353 }
50354
50355
50356 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50357 PyObject *resultobj = 0;
50358 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50359 wxWindow *arg2 = (wxWindow *) 0 ;
50360 wxGBPosition *arg3 = 0 ;
50361 bool result;
50362 void *argp1 = 0 ;
50363 int res1 = 0 ;
50364 void *argp2 = 0 ;
50365 int res2 = 0 ;
50366 wxGBPosition temp3 ;
50367
50368 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50370 if (!SWIG_IsOK(res1)) {
50371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50372 }
50373 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50374 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50375 if (!SWIG_IsOK(res2)) {
50376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50377 }
50378 arg2 = reinterpret_cast< wxWindow * >(argp2);
50379 {
50380 arg3 = &temp3;
50381 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50382 }
50383 {
50384 PyThreadState* __tstate = wxPyBeginAllowThreads();
50385 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50386 wxPyEndAllowThreads(__tstate);
50387 if (PyErr_Occurred()) SWIG_fail;
50388 }
50389 {
50390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50391 }
50392 return resultobj;
50393 fail:
50394 return NULL;
50395 }
50396
50397
50398 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50399 PyObject *resultobj = 0;
50400 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50401 wxSizer *arg2 = (wxSizer *) 0 ;
50402 wxGBPosition *arg3 = 0 ;
50403 bool result;
50404 void *argp1 = 0 ;
50405 int res1 = 0 ;
50406 void *argp2 = 0 ;
50407 int res2 = 0 ;
50408 wxGBPosition temp3 ;
50409
50410 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50412 if (!SWIG_IsOK(res1)) {
50413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50414 }
50415 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50416 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50417 if (!SWIG_IsOK(res2)) {
50418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50419 }
50420 arg2 = reinterpret_cast< wxSizer * >(argp2);
50421 {
50422 arg3 = &temp3;
50423 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50424 }
50425 {
50426 PyThreadState* __tstate = wxPyBeginAllowThreads();
50427 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50428 wxPyEndAllowThreads(__tstate);
50429 if (PyErr_Occurred()) SWIG_fail;
50430 }
50431 {
50432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50433 }
50434 return resultobj;
50435 fail:
50436 return NULL;
50437 }
50438
50439
50440 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50441 PyObject *resultobj = 0;
50442 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50443 size_t arg2 ;
50444 wxGBPosition *arg3 = 0 ;
50445 bool result;
50446 void *argp1 = 0 ;
50447 int res1 = 0 ;
50448 size_t val2 ;
50449 int ecode2 = 0 ;
50450 wxGBPosition temp3 ;
50451
50452 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50454 if (!SWIG_IsOK(res1)) {
50455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50456 }
50457 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50458 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50459 if (!SWIG_IsOK(ecode2)) {
50460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50461 }
50462 arg2 = static_cast< size_t >(val2);
50463 {
50464 arg3 = &temp3;
50465 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50466 }
50467 {
50468 PyThreadState* __tstate = wxPyBeginAllowThreads();
50469 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50470 wxPyEndAllowThreads(__tstate);
50471 if (PyErr_Occurred()) SWIG_fail;
50472 }
50473 {
50474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50475 }
50476 return resultobj;
50477 fail:
50478 return NULL;
50479 }
50480
50481
50482 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50483 int argc;
50484 PyObject *argv[4];
50485
50486 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50487 --argc;
50488 if (argc == 3) {
50489 int _v = 0;
50490 {
50491 void *vptr = 0;
50492 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50493 _v = SWIG_CheckState(res);
50494 }
50495 if (!_v) goto check_1;
50496 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50497 }
50498 check_1:
50499
50500 if (argc == 3) {
50501 int _v = 0;
50502 {
50503 void *vptr = 0;
50504 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50505 _v = SWIG_CheckState(res);
50506 }
50507 if (!_v) goto check_2;
50508 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50509 }
50510 check_2:
50511
50512 if (argc == 3) {
50513 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50514 }
50515
50516 fail:
50517 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50518 return NULL;
50519 }
50520
50521
50522 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50523 PyObject *resultobj = 0;
50524 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50525 wxWindow *arg2 = (wxWindow *) 0 ;
50526 wxGBSpan result;
50527 void *argp1 = 0 ;
50528 int res1 = 0 ;
50529 void *argp2 = 0 ;
50530 int res2 = 0 ;
50531
50532 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50534 if (!SWIG_IsOK(res1)) {
50535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50536 }
50537 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50538 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50539 if (!SWIG_IsOK(res2)) {
50540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50541 }
50542 arg2 = reinterpret_cast< wxWindow * >(argp2);
50543 {
50544 PyThreadState* __tstate = wxPyBeginAllowThreads();
50545 result = (arg1)->GetItemSpan(arg2);
50546 wxPyEndAllowThreads(__tstate);
50547 if (PyErr_Occurred()) SWIG_fail;
50548 }
50549 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50550 return resultobj;
50551 fail:
50552 return NULL;
50553 }
50554
50555
50556 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50557 PyObject *resultobj = 0;
50558 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50559 wxSizer *arg2 = (wxSizer *) 0 ;
50560 wxGBSpan result;
50561 void *argp1 = 0 ;
50562 int res1 = 0 ;
50563 void *argp2 = 0 ;
50564 int res2 = 0 ;
50565
50566 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50568 if (!SWIG_IsOK(res1)) {
50569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50570 }
50571 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50572 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50573 if (!SWIG_IsOK(res2)) {
50574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50575 }
50576 arg2 = reinterpret_cast< wxSizer * >(argp2);
50577 {
50578 PyThreadState* __tstate = wxPyBeginAllowThreads();
50579 result = (arg1)->GetItemSpan(arg2);
50580 wxPyEndAllowThreads(__tstate);
50581 if (PyErr_Occurred()) SWIG_fail;
50582 }
50583 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50584 return resultobj;
50585 fail:
50586 return NULL;
50587 }
50588
50589
50590 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50591 PyObject *resultobj = 0;
50592 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50593 size_t arg2 ;
50594 wxGBSpan result;
50595 void *argp1 = 0 ;
50596 int res1 = 0 ;
50597 size_t val2 ;
50598 int ecode2 = 0 ;
50599
50600 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50604 }
50605 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50606 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50607 if (!SWIG_IsOK(ecode2)) {
50608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50609 }
50610 arg2 = static_cast< size_t >(val2);
50611 {
50612 PyThreadState* __tstate = wxPyBeginAllowThreads();
50613 result = (arg1)->GetItemSpan(arg2);
50614 wxPyEndAllowThreads(__tstate);
50615 if (PyErr_Occurred()) SWIG_fail;
50616 }
50617 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50618 return resultobj;
50619 fail:
50620 return NULL;
50621 }
50622
50623
50624 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50625 int argc;
50626 PyObject *argv[3];
50627
50628 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50629 --argc;
50630 if (argc == 2) {
50631 int _v = 0;
50632 {
50633 void *vptr = 0;
50634 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50635 _v = SWIG_CheckState(res);
50636 }
50637 if (!_v) goto check_1;
50638 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50639 }
50640 check_1:
50641
50642 if (argc == 2) {
50643 int _v = 0;
50644 {
50645 void *vptr = 0;
50646 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50647 _v = SWIG_CheckState(res);
50648 }
50649 if (!_v) goto check_2;
50650 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50651 }
50652 check_2:
50653
50654 if (argc == 2) {
50655 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50656 }
50657
50658 fail:
50659 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50660 return NULL;
50661 }
50662
50663
50664 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50665 PyObject *resultobj = 0;
50666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50667 wxWindow *arg2 = (wxWindow *) 0 ;
50668 wxGBSpan *arg3 = 0 ;
50669 bool result;
50670 void *argp1 = 0 ;
50671 int res1 = 0 ;
50672 void *argp2 = 0 ;
50673 int res2 = 0 ;
50674 wxGBSpan temp3 ;
50675
50676 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50678 if (!SWIG_IsOK(res1)) {
50679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50680 }
50681 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50682 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50683 if (!SWIG_IsOK(res2)) {
50684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50685 }
50686 arg2 = reinterpret_cast< wxWindow * >(argp2);
50687 {
50688 arg3 = &temp3;
50689 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50690 }
50691 {
50692 PyThreadState* __tstate = wxPyBeginAllowThreads();
50693 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50694 wxPyEndAllowThreads(__tstate);
50695 if (PyErr_Occurred()) SWIG_fail;
50696 }
50697 {
50698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50699 }
50700 return resultobj;
50701 fail:
50702 return NULL;
50703 }
50704
50705
50706 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50707 PyObject *resultobj = 0;
50708 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50709 wxSizer *arg2 = (wxSizer *) 0 ;
50710 wxGBSpan *arg3 = 0 ;
50711 bool result;
50712 void *argp1 = 0 ;
50713 int res1 = 0 ;
50714 void *argp2 = 0 ;
50715 int res2 = 0 ;
50716 wxGBSpan temp3 ;
50717
50718 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50720 if (!SWIG_IsOK(res1)) {
50721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50722 }
50723 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50724 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50725 if (!SWIG_IsOK(res2)) {
50726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50727 }
50728 arg2 = reinterpret_cast< wxSizer * >(argp2);
50729 {
50730 arg3 = &temp3;
50731 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50732 }
50733 {
50734 PyThreadState* __tstate = wxPyBeginAllowThreads();
50735 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50736 wxPyEndAllowThreads(__tstate);
50737 if (PyErr_Occurred()) SWIG_fail;
50738 }
50739 {
50740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50741 }
50742 return resultobj;
50743 fail:
50744 return NULL;
50745 }
50746
50747
50748 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50749 PyObject *resultobj = 0;
50750 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50751 size_t arg2 ;
50752 wxGBSpan *arg3 = 0 ;
50753 bool result;
50754 void *argp1 = 0 ;
50755 int res1 = 0 ;
50756 size_t val2 ;
50757 int ecode2 = 0 ;
50758 wxGBSpan temp3 ;
50759
50760 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50762 if (!SWIG_IsOK(res1)) {
50763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50764 }
50765 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50766 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50767 if (!SWIG_IsOK(ecode2)) {
50768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50769 }
50770 arg2 = static_cast< size_t >(val2);
50771 {
50772 arg3 = &temp3;
50773 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50774 }
50775 {
50776 PyThreadState* __tstate = wxPyBeginAllowThreads();
50777 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50778 wxPyEndAllowThreads(__tstate);
50779 if (PyErr_Occurred()) SWIG_fail;
50780 }
50781 {
50782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50783 }
50784 return resultobj;
50785 fail:
50786 return NULL;
50787 }
50788
50789
50790 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50791 int argc;
50792 PyObject *argv[4];
50793
50794 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50795 --argc;
50796 if (argc == 3) {
50797 int _v = 0;
50798 {
50799 void *vptr = 0;
50800 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50801 _v = SWIG_CheckState(res);
50802 }
50803 if (!_v) goto check_1;
50804 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50805 }
50806 check_1:
50807
50808 if (argc == 3) {
50809 int _v = 0;
50810 {
50811 void *vptr = 0;
50812 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50813 _v = SWIG_CheckState(res);
50814 }
50815 if (!_v) goto check_2;
50816 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50817 }
50818 check_2:
50819
50820 if (argc == 3) {
50821 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50822 }
50823
50824 fail:
50825 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50826 return NULL;
50827 }
50828
50829
50830 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50831 PyObject *resultobj = 0;
50832 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50833 wxWindow *arg2 = (wxWindow *) 0 ;
50834 wxGBSizerItem *result = 0 ;
50835 void *argp1 = 0 ;
50836 int res1 = 0 ;
50837 void *argp2 = 0 ;
50838 int res2 = 0 ;
50839
50840 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50842 if (!SWIG_IsOK(res1)) {
50843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50844 }
50845 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50846 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50847 if (!SWIG_IsOK(res2)) {
50848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50849 }
50850 arg2 = reinterpret_cast< wxWindow * >(argp2);
50851 {
50852 PyThreadState* __tstate = wxPyBeginAllowThreads();
50853 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50854 wxPyEndAllowThreads(__tstate);
50855 if (PyErr_Occurred()) SWIG_fail;
50856 }
50857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50858 return resultobj;
50859 fail:
50860 return NULL;
50861 }
50862
50863
50864 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50865 PyObject *resultobj = 0;
50866 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50867 wxSizer *arg2 = (wxSizer *) 0 ;
50868 wxGBSizerItem *result = 0 ;
50869 void *argp1 = 0 ;
50870 int res1 = 0 ;
50871 void *argp2 = 0 ;
50872 int res2 = 0 ;
50873
50874 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50876 if (!SWIG_IsOK(res1)) {
50877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50878 }
50879 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50880 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50881 if (!SWIG_IsOK(res2)) {
50882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50883 }
50884 arg2 = reinterpret_cast< wxSizer * >(argp2);
50885 {
50886 PyThreadState* __tstate = wxPyBeginAllowThreads();
50887 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50888 wxPyEndAllowThreads(__tstate);
50889 if (PyErr_Occurred()) SWIG_fail;
50890 }
50891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50892 return resultobj;
50893 fail:
50894 return NULL;
50895 }
50896
50897
50898 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50899 int argc;
50900 PyObject *argv[3];
50901
50902 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50903 --argc;
50904 if (argc == 2) {
50905 int _v = 0;
50906 {
50907 void *vptr = 0;
50908 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50909 _v = SWIG_CheckState(res);
50910 }
50911 if (!_v) goto check_1;
50912 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50913 }
50914 check_1:
50915
50916 if (argc == 2) {
50917 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50918 }
50919
50920 fail:
50921 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50922 return NULL;
50923 }
50924
50925
50926 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50927 PyObject *resultobj = 0;
50928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50929 wxGBPosition *arg2 = 0 ;
50930 wxGBSizerItem *result = 0 ;
50931 void *argp1 = 0 ;
50932 int res1 = 0 ;
50933 wxGBPosition temp2 ;
50934 PyObject * obj0 = 0 ;
50935 PyObject * obj1 = 0 ;
50936 char * kwnames[] = {
50937 (char *) "self",(char *) "pos", NULL
50938 };
50939
50940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50942 if (!SWIG_IsOK(res1)) {
50943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50944 }
50945 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50946 {
50947 arg2 = &temp2;
50948 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50949 }
50950 {
50951 PyThreadState* __tstate = wxPyBeginAllowThreads();
50952 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50953 wxPyEndAllowThreads(__tstate);
50954 if (PyErr_Occurred()) SWIG_fail;
50955 }
50956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50957 return resultobj;
50958 fail:
50959 return NULL;
50960 }
50961
50962
50963 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50964 PyObject *resultobj = 0;
50965 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50966 wxPoint *arg2 = 0 ;
50967 wxGBSizerItem *result = 0 ;
50968 void *argp1 = 0 ;
50969 int res1 = 0 ;
50970 wxPoint temp2 ;
50971 PyObject * obj0 = 0 ;
50972 PyObject * obj1 = 0 ;
50973 char * kwnames[] = {
50974 (char *) "self",(char *) "pt", NULL
50975 };
50976
50977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50979 if (!SWIG_IsOK(res1)) {
50980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50981 }
50982 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50983 {
50984 arg2 = &temp2;
50985 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50986 }
50987 {
50988 PyThreadState* __tstate = wxPyBeginAllowThreads();
50989 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50990 wxPyEndAllowThreads(__tstate);
50991 if (PyErr_Occurred()) SWIG_fail;
50992 }
50993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50994 return resultobj;
50995 fail:
50996 return NULL;
50997 }
50998
50999
51000 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51001 PyObject *resultobj = 0;
51002 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51003 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51004 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51005 bool result;
51006 void *argp1 = 0 ;
51007 int res1 = 0 ;
51008 void *argp2 = 0 ;
51009 int res2 = 0 ;
51010 void *argp3 = 0 ;
51011 int res3 = 0 ;
51012 PyObject * obj0 = 0 ;
51013 PyObject * obj1 = 0 ;
51014 PyObject * obj2 = 0 ;
51015 char * kwnames[] = {
51016 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51017 };
51018
51019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51021 if (!SWIG_IsOK(res1)) {
51022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51023 }
51024 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51026 if (!SWIG_IsOK(res2)) {
51027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51028 }
51029 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51030 if (obj2) {
51031 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51032 if (!SWIG_IsOK(res3)) {
51033 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51034 }
51035 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51036 }
51037 {
51038 PyThreadState* __tstate = wxPyBeginAllowThreads();
51039 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51040 wxPyEndAllowThreads(__tstate);
51041 if (PyErr_Occurred()) SWIG_fail;
51042 }
51043 {
51044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51045 }
51046 return resultobj;
51047 fail:
51048 return NULL;
51049 }
51050
51051
51052 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51053 PyObject *resultobj = 0;
51054 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51055 wxGBPosition *arg2 = 0 ;
51056 wxGBSpan *arg3 = 0 ;
51057 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51058 bool result;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 wxGBPosition temp2 ;
51062 wxGBSpan temp3 ;
51063 void *argp4 = 0 ;
51064 int res4 = 0 ;
51065 PyObject * obj0 = 0 ;
51066 PyObject * obj1 = 0 ;
51067 PyObject * obj2 = 0 ;
51068 PyObject * obj3 = 0 ;
51069 char * kwnames[] = {
51070 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51071 };
51072
51073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51075 if (!SWIG_IsOK(res1)) {
51076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51077 }
51078 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51079 {
51080 arg2 = &temp2;
51081 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51082 }
51083 {
51084 arg3 = &temp3;
51085 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51086 }
51087 if (obj3) {
51088 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51089 if (!SWIG_IsOK(res4)) {
51090 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51091 }
51092 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51093 }
51094 {
51095 PyThreadState* __tstate = wxPyBeginAllowThreads();
51096 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51097 wxPyEndAllowThreads(__tstate);
51098 if (PyErr_Occurred()) SWIG_fail;
51099 }
51100 {
51101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51102 }
51103 return resultobj;
51104 fail:
51105 return NULL;
51106 }
51107
51108
51109 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51110 PyObject *obj;
51111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51112 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51113 return SWIG_Py_Void();
51114 }
51115
51116 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51117 return SWIG_Python_InitShadowInstance(args);
51118 }
51119
51120 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51121 PyObject *resultobj = 0;
51122 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51123 wxRelationship arg2 ;
51124 wxWindow *arg3 = (wxWindow *) 0 ;
51125 wxEdge arg4 ;
51126 int arg5 = (int) 0 ;
51127 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51128 void *argp1 = 0 ;
51129 int res1 = 0 ;
51130 int val2 ;
51131 int ecode2 = 0 ;
51132 void *argp3 = 0 ;
51133 int res3 = 0 ;
51134 int val4 ;
51135 int ecode4 = 0 ;
51136 int val5 ;
51137 int ecode5 = 0 ;
51138 int val6 ;
51139 int ecode6 = 0 ;
51140 PyObject * obj0 = 0 ;
51141 PyObject * obj1 = 0 ;
51142 PyObject * obj2 = 0 ;
51143 PyObject * obj3 = 0 ;
51144 PyObject * obj4 = 0 ;
51145 PyObject * obj5 = 0 ;
51146 char * kwnames[] = {
51147 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51148 };
51149
51150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51152 if (!SWIG_IsOK(res1)) {
51153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51154 }
51155 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51156 ecode2 = SWIG_AsVal_int(obj1, &val2);
51157 if (!SWIG_IsOK(ecode2)) {
51158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51159 }
51160 arg2 = static_cast< wxRelationship >(val2);
51161 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51162 if (!SWIG_IsOK(res3)) {
51163 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51164 }
51165 arg3 = reinterpret_cast< wxWindow * >(argp3);
51166 ecode4 = SWIG_AsVal_int(obj3, &val4);
51167 if (!SWIG_IsOK(ecode4)) {
51168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51169 }
51170 arg4 = static_cast< wxEdge >(val4);
51171 if (obj4) {
51172 ecode5 = SWIG_AsVal_int(obj4, &val5);
51173 if (!SWIG_IsOK(ecode5)) {
51174 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51175 }
51176 arg5 = static_cast< int >(val5);
51177 }
51178 if (obj5) {
51179 ecode6 = SWIG_AsVal_int(obj5, &val6);
51180 if (!SWIG_IsOK(ecode6)) {
51181 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51182 }
51183 arg6 = static_cast< int >(val6);
51184 }
51185 {
51186 PyThreadState* __tstate = wxPyBeginAllowThreads();
51187 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51188 wxPyEndAllowThreads(__tstate);
51189 if (PyErr_Occurred()) SWIG_fail;
51190 }
51191 resultobj = SWIG_Py_Void();
51192 return resultobj;
51193 fail:
51194 return NULL;
51195 }
51196
51197
51198 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51199 PyObject *resultobj = 0;
51200 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51201 wxWindow *arg2 = (wxWindow *) 0 ;
51202 int arg3 = (int) 0 ;
51203 void *argp1 = 0 ;
51204 int res1 = 0 ;
51205 void *argp2 = 0 ;
51206 int res2 = 0 ;
51207 int val3 ;
51208 int ecode3 = 0 ;
51209 PyObject * obj0 = 0 ;
51210 PyObject * obj1 = 0 ;
51211 PyObject * obj2 = 0 ;
51212 char * kwnames[] = {
51213 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51214 };
51215
51216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51218 if (!SWIG_IsOK(res1)) {
51219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51220 }
51221 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51223 if (!SWIG_IsOK(res2)) {
51224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51225 }
51226 arg2 = reinterpret_cast< wxWindow * >(argp2);
51227 if (obj2) {
51228 ecode3 = SWIG_AsVal_int(obj2, &val3);
51229 if (!SWIG_IsOK(ecode3)) {
51230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51231 }
51232 arg3 = static_cast< int >(val3);
51233 }
51234 {
51235 PyThreadState* __tstate = wxPyBeginAllowThreads();
51236 (arg1)->LeftOf(arg2,arg3);
51237 wxPyEndAllowThreads(__tstate);
51238 if (PyErr_Occurred()) SWIG_fail;
51239 }
51240 resultobj = SWIG_Py_Void();
51241 return resultobj;
51242 fail:
51243 return NULL;
51244 }
51245
51246
51247 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51248 PyObject *resultobj = 0;
51249 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51250 wxWindow *arg2 = (wxWindow *) 0 ;
51251 int arg3 = (int) 0 ;
51252 void *argp1 = 0 ;
51253 int res1 = 0 ;
51254 void *argp2 = 0 ;
51255 int res2 = 0 ;
51256 int val3 ;
51257 int ecode3 = 0 ;
51258 PyObject * obj0 = 0 ;
51259 PyObject * obj1 = 0 ;
51260 PyObject * obj2 = 0 ;
51261 char * kwnames[] = {
51262 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51263 };
51264
51265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51267 if (!SWIG_IsOK(res1)) {
51268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51269 }
51270 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51272 if (!SWIG_IsOK(res2)) {
51273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51274 }
51275 arg2 = reinterpret_cast< wxWindow * >(argp2);
51276 if (obj2) {
51277 ecode3 = SWIG_AsVal_int(obj2, &val3);
51278 if (!SWIG_IsOK(ecode3)) {
51279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51280 }
51281 arg3 = static_cast< int >(val3);
51282 }
51283 {
51284 PyThreadState* __tstate = wxPyBeginAllowThreads();
51285 (arg1)->RightOf(arg2,arg3);
51286 wxPyEndAllowThreads(__tstate);
51287 if (PyErr_Occurred()) SWIG_fail;
51288 }
51289 resultobj = SWIG_Py_Void();
51290 return resultobj;
51291 fail:
51292 return NULL;
51293 }
51294
51295
51296 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51297 PyObject *resultobj = 0;
51298 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51299 wxWindow *arg2 = (wxWindow *) 0 ;
51300 int arg3 = (int) 0 ;
51301 void *argp1 = 0 ;
51302 int res1 = 0 ;
51303 void *argp2 = 0 ;
51304 int res2 = 0 ;
51305 int val3 ;
51306 int ecode3 = 0 ;
51307 PyObject * obj0 = 0 ;
51308 PyObject * obj1 = 0 ;
51309 PyObject * obj2 = 0 ;
51310 char * kwnames[] = {
51311 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51312 };
51313
51314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51316 if (!SWIG_IsOK(res1)) {
51317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51318 }
51319 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51321 if (!SWIG_IsOK(res2)) {
51322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51323 }
51324 arg2 = reinterpret_cast< wxWindow * >(argp2);
51325 if (obj2) {
51326 ecode3 = SWIG_AsVal_int(obj2, &val3);
51327 if (!SWIG_IsOK(ecode3)) {
51328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51329 }
51330 arg3 = static_cast< int >(val3);
51331 }
51332 {
51333 PyThreadState* __tstate = wxPyBeginAllowThreads();
51334 (arg1)->Above(arg2,arg3);
51335 wxPyEndAllowThreads(__tstate);
51336 if (PyErr_Occurred()) SWIG_fail;
51337 }
51338 resultobj = SWIG_Py_Void();
51339 return resultobj;
51340 fail:
51341 return NULL;
51342 }
51343
51344
51345 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51346 PyObject *resultobj = 0;
51347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51348 wxWindow *arg2 = (wxWindow *) 0 ;
51349 int arg3 = (int) 0 ;
51350 void *argp1 = 0 ;
51351 int res1 = 0 ;
51352 void *argp2 = 0 ;
51353 int res2 = 0 ;
51354 int val3 ;
51355 int ecode3 = 0 ;
51356 PyObject * obj0 = 0 ;
51357 PyObject * obj1 = 0 ;
51358 PyObject * obj2 = 0 ;
51359 char * kwnames[] = {
51360 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51361 };
51362
51363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51365 if (!SWIG_IsOK(res1)) {
51366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51367 }
51368 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51370 if (!SWIG_IsOK(res2)) {
51371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51372 }
51373 arg2 = reinterpret_cast< wxWindow * >(argp2);
51374 if (obj2) {
51375 ecode3 = SWIG_AsVal_int(obj2, &val3);
51376 if (!SWIG_IsOK(ecode3)) {
51377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51378 }
51379 arg3 = static_cast< int >(val3);
51380 }
51381 {
51382 PyThreadState* __tstate = wxPyBeginAllowThreads();
51383 (arg1)->Below(arg2,arg3);
51384 wxPyEndAllowThreads(__tstate);
51385 if (PyErr_Occurred()) SWIG_fail;
51386 }
51387 resultobj = SWIG_Py_Void();
51388 return resultobj;
51389 fail:
51390 return NULL;
51391 }
51392
51393
51394 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51395 PyObject *resultobj = 0;
51396 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51397 wxWindow *arg2 = (wxWindow *) 0 ;
51398 wxEdge arg3 ;
51399 int arg4 = (int) 0 ;
51400 void *argp1 = 0 ;
51401 int res1 = 0 ;
51402 void *argp2 = 0 ;
51403 int res2 = 0 ;
51404 int val3 ;
51405 int ecode3 = 0 ;
51406 int val4 ;
51407 int ecode4 = 0 ;
51408 PyObject * obj0 = 0 ;
51409 PyObject * obj1 = 0 ;
51410 PyObject * obj2 = 0 ;
51411 PyObject * obj3 = 0 ;
51412 char * kwnames[] = {
51413 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51414 };
51415
51416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51418 if (!SWIG_IsOK(res1)) {
51419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51420 }
51421 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51423 if (!SWIG_IsOK(res2)) {
51424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51425 }
51426 arg2 = reinterpret_cast< wxWindow * >(argp2);
51427 ecode3 = SWIG_AsVal_int(obj2, &val3);
51428 if (!SWIG_IsOK(ecode3)) {
51429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51430 }
51431 arg3 = static_cast< wxEdge >(val3);
51432 if (obj3) {
51433 ecode4 = SWIG_AsVal_int(obj3, &val4);
51434 if (!SWIG_IsOK(ecode4)) {
51435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51436 }
51437 arg4 = static_cast< int >(val4);
51438 }
51439 {
51440 PyThreadState* __tstate = wxPyBeginAllowThreads();
51441 (arg1)->SameAs(arg2,arg3,arg4);
51442 wxPyEndAllowThreads(__tstate);
51443 if (PyErr_Occurred()) SWIG_fail;
51444 }
51445 resultobj = SWIG_Py_Void();
51446 return resultobj;
51447 fail:
51448 return NULL;
51449 }
51450
51451
51452 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51453 PyObject *resultobj = 0;
51454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51455 wxWindow *arg2 = (wxWindow *) 0 ;
51456 wxEdge arg3 ;
51457 int arg4 ;
51458 void *argp1 = 0 ;
51459 int res1 = 0 ;
51460 void *argp2 = 0 ;
51461 int res2 = 0 ;
51462 int val3 ;
51463 int ecode3 = 0 ;
51464 int val4 ;
51465 int ecode4 = 0 ;
51466 PyObject * obj0 = 0 ;
51467 PyObject * obj1 = 0 ;
51468 PyObject * obj2 = 0 ;
51469 PyObject * obj3 = 0 ;
51470 char * kwnames[] = {
51471 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51472 };
51473
51474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51476 if (!SWIG_IsOK(res1)) {
51477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51478 }
51479 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51481 if (!SWIG_IsOK(res2)) {
51482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51483 }
51484 arg2 = reinterpret_cast< wxWindow * >(argp2);
51485 ecode3 = SWIG_AsVal_int(obj2, &val3);
51486 if (!SWIG_IsOK(ecode3)) {
51487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51488 }
51489 arg3 = static_cast< wxEdge >(val3);
51490 ecode4 = SWIG_AsVal_int(obj3, &val4);
51491 if (!SWIG_IsOK(ecode4)) {
51492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51493 }
51494 arg4 = static_cast< int >(val4);
51495 {
51496 PyThreadState* __tstate = wxPyBeginAllowThreads();
51497 (arg1)->PercentOf(arg2,arg3,arg4);
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_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51509 PyObject *resultobj = 0;
51510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 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 *) "val", NULL
51520 };
51521
51522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51524 if (!SWIG_IsOK(res1)) {
51525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51526 }
51527 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51528 ecode2 = SWIG_AsVal_int(obj1, &val2);
51529 if (!SWIG_IsOK(ecode2)) {
51530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51531 }
51532 arg2 = static_cast< int >(val2);
51533 {
51534 PyThreadState* __tstate = wxPyBeginAllowThreads();
51535 (arg1)->Absolute(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_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51547 PyObject *resultobj = 0;
51548 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51549 void *argp1 = 0 ;
51550 int res1 = 0 ;
51551 PyObject *swig_obj[1] ;
51552
51553 if (!args) SWIG_fail;
51554 swig_obj[0] = args;
51555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51556 if (!SWIG_IsOK(res1)) {
51557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51558 }
51559 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51560 {
51561 PyThreadState* __tstate = wxPyBeginAllowThreads();
51562 (arg1)->Unconstrained();
51563 wxPyEndAllowThreads(__tstate);
51564 if (PyErr_Occurred()) SWIG_fail;
51565 }
51566 resultobj = SWIG_Py_Void();
51567 return resultobj;
51568 fail:
51569 return NULL;
51570 }
51571
51572
51573 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51574 PyObject *resultobj = 0;
51575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51576 void *argp1 = 0 ;
51577 int res1 = 0 ;
51578 PyObject *swig_obj[1] ;
51579
51580 if (!args) SWIG_fail;
51581 swig_obj[0] = args;
51582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51583 if (!SWIG_IsOK(res1)) {
51584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51585 }
51586 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51587 {
51588 PyThreadState* __tstate = wxPyBeginAllowThreads();
51589 (arg1)->AsIs();
51590 wxPyEndAllowThreads(__tstate);
51591 if (PyErr_Occurred()) SWIG_fail;
51592 }
51593 resultobj = SWIG_Py_Void();
51594 return resultobj;
51595 fail:
51596 return NULL;
51597 }
51598
51599
51600 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51601 PyObject *resultobj = 0;
51602 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51603 wxWindow *result = 0 ;
51604 void *argp1 = 0 ;
51605 int res1 = 0 ;
51606 PyObject *swig_obj[1] ;
51607
51608 if (!args) SWIG_fail;
51609 swig_obj[0] = args;
51610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51611 if (!SWIG_IsOK(res1)) {
51612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51613 }
51614 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51615 {
51616 PyThreadState* __tstate = wxPyBeginAllowThreads();
51617 result = (wxWindow *)(arg1)->GetOtherWindow();
51618 wxPyEndAllowThreads(__tstate);
51619 if (PyErr_Occurred()) SWIG_fail;
51620 }
51621 {
51622 resultobj = wxPyMake_wxObject(result, 0);
51623 }
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51631 PyObject *resultobj = 0;
51632 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51633 wxEdge 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_wxIndividualLayoutConstraint, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51643 }
51644 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
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 *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51659 PyObject *resultobj = 0;
51660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51661 wxEdge arg2 ;
51662 void *argp1 = 0 ;
51663 int res1 = 0 ;
51664 int val2 ;
51665 int ecode2 = 0 ;
51666 PyObject * obj0 = 0 ;
51667 PyObject * obj1 = 0 ;
51668 char * kwnames[] = {
51669 (char *) "self",(char *) "which", NULL
51670 };
51671
51672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51674 if (!SWIG_IsOK(res1)) {
51675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51676 }
51677 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51678 ecode2 = SWIG_AsVal_int(obj1, &val2);
51679 if (!SWIG_IsOK(ecode2)) {
51680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51681 }
51682 arg2 = static_cast< wxEdge >(val2);
51683 {
51684 PyThreadState* __tstate = wxPyBeginAllowThreads();
51685 (arg1)->SetEdge(arg2);
51686 wxPyEndAllowThreads(__tstate);
51687 if (PyErr_Occurred()) SWIG_fail;
51688 }
51689 resultobj = SWIG_Py_Void();
51690 return resultobj;
51691 fail:
51692 return NULL;
51693 }
51694
51695
51696 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51697 PyObject *resultobj = 0;
51698 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51699 int arg2 ;
51700 void *argp1 = 0 ;
51701 int res1 = 0 ;
51702 int val2 ;
51703 int ecode2 = 0 ;
51704 PyObject * obj0 = 0 ;
51705 PyObject * obj1 = 0 ;
51706 char * kwnames[] = {
51707 (char *) "self",(char *) "v", NULL
51708 };
51709
51710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51712 if (!SWIG_IsOK(res1)) {
51713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51714 }
51715 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51716 ecode2 = SWIG_AsVal_int(obj1, &val2);
51717 if (!SWIG_IsOK(ecode2)) {
51718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51719 }
51720 arg2 = static_cast< int >(val2);
51721 {
51722 PyThreadState* __tstate = wxPyBeginAllowThreads();
51723 (arg1)->SetValue(arg2);
51724 wxPyEndAllowThreads(__tstate);
51725 if (PyErr_Occurred()) SWIG_fail;
51726 }
51727 resultobj = SWIG_Py_Void();
51728 return resultobj;
51729 fail:
51730 return NULL;
51731 }
51732
51733
51734 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51735 PyObject *resultobj = 0;
51736 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51737 int result;
51738 void *argp1 = 0 ;
51739 int res1 = 0 ;
51740 PyObject *swig_obj[1] ;
51741
51742 if (!args) SWIG_fail;
51743 swig_obj[0] = args;
51744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51745 if (!SWIG_IsOK(res1)) {
51746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51747 }
51748 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51749 {
51750 PyThreadState* __tstate = wxPyBeginAllowThreads();
51751 result = (int)(arg1)->GetMargin();
51752 wxPyEndAllowThreads(__tstate);
51753 if (PyErr_Occurred()) SWIG_fail;
51754 }
51755 resultobj = SWIG_From_int(static_cast< int >(result));
51756 return resultobj;
51757 fail:
51758 return NULL;
51759 }
51760
51761
51762 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51763 PyObject *resultobj = 0;
51764 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51765 int arg2 ;
51766 void *argp1 = 0 ;
51767 int res1 = 0 ;
51768 int val2 ;
51769 int ecode2 = 0 ;
51770 PyObject * obj0 = 0 ;
51771 PyObject * obj1 = 0 ;
51772 char * kwnames[] = {
51773 (char *) "self",(char *) "m", NULL
51774 };
51775
51776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51778 if (!SWIG_IsOK(res1)) {
51779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51780 }
51781 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51782 ecode2 = SWIG_AsVal_int(obj1, &val2);
51783 if (!SWIG_IsOK(ecode2)) {
51784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51785 }
51786 arg2 = static_cast< int >(val2);
51787 {
51788 PyThreadState* __tstate = wxPyBeginAllowThreads();
51789 (arg1)->SetMargin(arg2);
51790 wxPyEndAllowThreads(__tstate);
51791 if (PyErr_Occurred()) SWIG_fail;
51792 }
51793 resultobj = SWIG_Py_Void();
51794 return resultobj;
51795 fail:
51796 return NULL;
51797 }
51798
51799
51800 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51801 PyObject *resultobj = 0;
51802 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51803 int result;
51804 void *argp1 = 0 ;
51805 int res1 = 0 ;
51806 PyObject *swig_obj[1] ;
51807
51808 if (!args) SWIG_fail;
51809 swig_obj[0] = args;
51810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51811 if (!SWIG_IsOK(res1)) {
51812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51813 }
51814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51815 {
51816 PyThreadState* __tstate = wxPyBeginAllowThreads();
51817 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51818 wxPyEndAllowThreads(__tstate);
51819 if (PyErr_Occurred()) SWIG_fail;
51820 }
51821 resultobj = SWIG_From_int(static_cast< int >(result));
51822 return resultobj;
51823 fail:
51824 return NULL;
51825 }
51826
51827
51828 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51829 PyObject *resultobj = 0;
51830 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51831 int result;
51832 void *argp1 = 0 ;
51833 int res1 = 0 ;
51834 PyObject *swig_obj[1] ;
51835
51836 if (!args) SWIG_fail;
51837 swig_obj[0] = args;
51838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51839 if (!SWIG_IsOK(res1)) {
51840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51841 }
51842 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51843 {
51844 PyThreadState* __tstate = wxPyBeginAllowThreads();
51845 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51846 wxPyEndAllowThreads(__tstate);
51847 if (PyErr_Occurred()) SWIG_fail;
51848 }
51849 resultobj = SWIG_From_int(static_cast< int >(result));
51850 return resultobj;
51851 fail:
51852 return NULL;
51853 }
51854
51855
51856 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51857 PyObject *resultobj = 0;
51858 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51859 int result;
51860 void *argp1 = 0 ;
51861 int res1 = 0 ;
51862 PyObject *swig_obj[1] ;
51863
51864 if (!args) SWIG_fail;
51865 swig_obj[0] = args;
51866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51867 if (!SWIG_IsOK(res1)) {
51868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51869 }
51870 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51871 {
51872 PyThreadState* __tstate = wxPyBeginAllowThreads();
51873 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51874 wxPyEndAllowThreads(__tstate);
51875 if (PyErr_Occurred()) SWIG_fail;
51876 }
51877 resultobj = SWIG_From_int(static_cast< int >(result));
51878 return resultobj;
51879 fail:
51880 return NULL;
51881 }
51882
51883
51884 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51885 PyObject *resultobj = 0;
51886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51887 bool result;
51888 void *argp1 = 0 ;
51889 int res1 = 0 ;
51890 PyObject *swig_obj[1] ;
51891
51892 if (!args) SWIG_fail;
51893 swig_obj[0] = args;
51894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51895 if (!SWIG_IsOK(res1)) {
51896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51897 }
51898 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51899 {
51900 PyThreadState* __tstate = wxPyBeginAllowThreads();
51901 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51902 wxPyEndAllowThreads(__tstate);
51903 if (PyErr_Occurred()) SWIG_fail;
51904 }
51905 {
51906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51907 }
51908 return resultobj;
51909 fail:
51910 return NULL;
51911 }
51912
51913
51914 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51915 PyObject *resultobj = 0;
51916 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51917 bool arg2 ;
51918 void *argp1 = 0 ;
51919 int res1 = 0 ;
51920 bool val2 ;
51921 int ecode2 = 0 ;
51922 PyObject * obj0 = 0 ;
51923 PyObject * obj1 = 0 ;
51924 char * kwnames[] = {
51925 (char *) "self",(char *) "d", NULL
51926 };
51927
51928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51930 if (!SWIG_IsOK(res1)) {
51931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51932 }
51933 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51935 if (!SWIG_IsOK(ecode2)) {
51936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51937 }
51938 arg2 = static_cast< bool >(val2);
51939 {
51940 PyThreadState* __tstate = wxPyBeginAllowThreads();
51941 (arg1)->SetDone(arg2);
51942 wxPyEndAllowThreads(__tstate);
51943 if (PyErr_Occurred()) SWIG_fail;
51944 }
51945 resultobj = SWIG_Py_Void();
51946 return resultobj;
51947 fail:
51948 return NULL;
51949 }
51950
51951
51952 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51953 PyObject *resultobj = 0;
51954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51955 wxRelationship result;
51956 void *argp1 = 0 ;
51957 int res1 = 0 ;
51958 PyObject *swig_obj[1] ;
51959
51960 if (!args) SWIG_fail;
51961 swig_obj[0] = args;
51962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51963 if (!SWIG_IsOK(res1)) {
51964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51965 }
51966 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51967 {
51968 PyThreadState* __tstate = wxPyBeginAllowThreads();
51969 result = (wxRelationship)(arg1)->GetRelationship();
51970 wxPyEndAllowThreads(__tstate);
51971 if (PyErr_Occurred()) SWIG_fail;
51972 }
51973 resultobj = SWIG_From_int(static_cast< int >(result));
51974 return resultobj;
51975 fail:
51976 return NULL;
51977 }
51978
51979
51980 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51981 PyObject *resultobj = 0;
51982 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51983 wxRelationship arg2 ;
51984 void *argp1 = 0 ;
51985 int res1 = 0 ;
51986 int val2 ;
51987 int ecode2 = 0 ;
51988 PyObject * obj0 = 0 ;
51989 PyObject * obj1 = 0 ;
51990 char * kwnames[] = {
51991 (char *) "self",(char *) "r", NULL
51992 };
51993
51994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51996 if (!SWIG_IsOK(res1)) {
51997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51998 }
51999 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52000 ecode2 = SWIG_AsVal_int(obj1, &val2);
52001 if (!SWIG_IsOK(ecode2)) {
52002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52003 }
52004 arg2 = static_cast< wxRelationship >(val2);
52005 {
52006 PyThreadState* __tstate = wxPyBeginAllowThreads();
52007 (arg1)->SetRelationship(arg2);
52008 wxPyEndAllowThreads(__tstate);
52009 if (PyErr_Occurred()) SWIG_fail;
52010 }
52011 resultobj = SWIG_Py_Void();
52012 return resultobj;
52013 fail:
52014 return NULL;
52015 }
52016
52017
52018 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52019 PyObject *resultobj = 0;
52020 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52021 wxWindow *arg2 = (wxWindow *) 0 ;
52022 bool result;
52023 void *argp1 = 0 ;
52024 int res1 = 0 ;
52025 void *argp2 = 0 ;
52026 int res2 = 0 ;
52027 PyObject * obj0 = 0 ;
52028 PyObject * obj1 = 0 ;
52029 char * kwnames[] = {
52030 (char *) "self",(char *) "otherW", NULL
52031 };
52032
52033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52035 if (!SWIG_IsOK(res1)) {
52036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52037 }
52038 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52040 if (!SWIG_IsOK(res2)) {
52041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52042 }
52043 arg2 = reinterpret_cast< wxWindow * >(argp2);
52044 {
52045 PyThreadState* __tstate = wxPyBeginAllowThreads();
52046 result = (bool)(arg1)->ResetIfWin(arg2);
52047 wxPyEndAllowThreads(__tstate);
52048 if (PyErr_Occurred()) SWIG_fail;
52049 }
52050 {
52051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52052 }
52053 return resultobj;
52054 fail:
52055 return NULL;
52056 }
52057
52058
52059 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52060 PyObject *resultobj = 0;
52061 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52062 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52063 wxWindow *arg3 = (wxWindow *) 0 ;
52064 bool result;
52065 void *argp1 = 0 ;
52066 int res1 = 0 ;
52067 void *argp2 = 0 ;
52068 int res2 = 0 ;
52069 void *argp3 = 0 ;
52070 int res3 = 0 ;
52071 PyObject * obj0 = 0 ;
52072 PyObject * obj1 = 0 ;
52073 PyObject * obj2 = 0 ;
52074 char * kwnames[] = {
52075 (char *) "self",(char *) "constraints",(char *) "win", NULL
52076 };
52077
52078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52080 if (!SWIG_IsOK(res1)) {
52081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52082 }
52083 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52085 if (!SWIG_IsOK(res2)) {
52086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52087 }
52088 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52089 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52090 if (!SWIG_IsOK(res3)) {
52091 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52092 }
52093 arg3 = reinterpret_cast< wxWindow * >(argp3);
52094 {
52095 PyThreadState* __tstate = wxPyBeginAllowThreads();
52096 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52097 wxPyEndAllowThreads(__tstate);
52098 if (PyErr_Occurred()) SWIG_fail;
52099 }
52100 {
52101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52102 }
52103 return resultobj;
52104 fail:
52105 return NULL;
52106 }
52107
52108
52109 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52110 PyObject *resultobj = 0;
52111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52112 wxEdge arg2 ;
52113 wxWindow *arg3 = (wxWindow *) 0 ;
52114 wxWindow *arg4 = (wxWindow *) 0 ;
52115 int result;
52116 void *argp1 = 0 ;
52117 int res1 = 0 ;
52118 int val2 ;
52119 int ecode2 = 0 ;
52120 void *argp3 = 0 ;
52121 int res3 = 0 ;
52122 void *argp4 = 0 ;
52123 int res4 = 0 ;
52124 PyObject * obj0 = 0 ;
52125 PyObject * obj1 = 0 ;
52126 PyObject * obj2 = 0 ;
52127 PyObject * obj3 = 0 ;
52128 char * kwnames[] = {
52129 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52130 };
52131
52132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52134 if (!SWIG_IsOK(res1)) {
52135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52136 }
52137 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52138 ecode2 = SWIG_AsVal_int(obj1, &val2);
52139 if (!SWIG_IsOK(ecode2)) {
52140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52141 }
52142 arg2 = static_cast< wxEdge >(val2);
52143 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52144 if (!SWIG_IsOK(res3)) {
52145 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52146 }
52147 arg3 = reinterpret_cast< wxWindow * >(argp3);
52148 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52149 if (!SWIG_IsOK(res4)) {
52150 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52151 }
52152 arg4 = reinterpret_cast< wxWindow * >(argp4);
52153 {
52154 PyThreadState* __tstate = wxPyBeginAllowThreads();
52155 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52156 wxPyEndAllowThreads(__tstate);
52157 if (PyErr_Occurred()) SWIG_fail;
52158 }
52159 resultobj = SWIG_From_int(static_cast< int >(result));
52160 return resultobj;
52161 fail:
52162 return NULL;
52163 }
52164
52165
52166 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52167 PyObject *obj;
52168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52169 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52170 return SWIG_Py_Void();
52171 }
52172
52173 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52174 PyObject *resultobj = 0;
52175 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52176 wxIndividualLayoutConstraint *result = 0 ;
52177 void *argp1 = 0 ;
52178 int res1 = 0 ;
52179 PyObject *swig_obj[1] ;
52180
52181 if (!args) SWIG_fail;
52182 swig_obj[0] = args;
52183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52184 if (!SWIG_IsOK(res1)) {
52185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52186 }
52187 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52188 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52190 return resultobj;
52191 fail:
52192 return NULL;
52193 }
52194
52195
52196 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52197 PyObject *resultobj = 0;
52198 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52199 wxIndividualLayoutConstraint *result = 0 ;
52200 void *argp1 = 0 ;
52201 int res1 = 0 ;
52202 PyObject *swig_obj[1] ;
52203
52204 if (!args) SWIG_fail;
52205 swig_obj[0] = args;
52206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52207 if (!SWIG_IsOK(res1)) {
52208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52209 }
52210 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52211 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52213 return resultobj;
52214 fail:
52215 return NULL;
52216 }
52217
52218
52219 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52220 PyObject *resultobj = 0;
52221 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52222 wxIndividualLayoutConstraint *result = 0 ;
52223 void *argp1 = 0 ;
52224 int res1 = 0 ;
52225 PyObject *swig_obj[1] ;
52226
52227 if (!args) SWIG_fail;
52228 swig_obj[0] = args;
52229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52230 if (!SWIG_IsOK(res1)) {
52231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52232 }
52233 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52234 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52236 return resultobj;
52237 fail:
52238 return NULL;
52239 }
52240
52241
52242 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52243 PyObject *resultobj = 0;
52244 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52245 wxIndividualLayoutConstraint *result = 0 ;
52246 void *argp1 = 0 ;
52247 int res1 = 0 ;
52248 PyObject *swig_obj[1] ;
52249
52250 if (!args) SWIG_fail;
52251 swig_obj[0] = args;
52252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52255 }
52256 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52257 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52259 return resultobj;
52260 fail:
52261 return NULL;
52262 }
52263
52264
52265 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52266 PyObject *resultobj = 0;
52267 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52268 wxIndividualLayoutConstraint *result = 0 ;
52269 void *argp1 = 0 ;
52270 int res1 = 0 ;
52271 PyObject *swig_obj[1] ;
52272
52273 if (!args) SWIG_fail;
52274 swig_obj[0] = args;
52275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52276 if (!SWIG_IsOK(res1)) {
52277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52278 }
52279 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52280 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52282 return resultobj;
52283 fail:
52284 return NULL;
52285 }
52286
52287
52288 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52289 PyObject *resultobj = 0;
52290 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52291 wxIndividualLayoutConstraint *result = 0 ;
52292 void *argp1 = 0 ;
52293 int res1 = 0 ;
52294 PyObject *swig_obj[1] ;
52295
52296 if (!args) SWIG_fail;
52297 swig_obj[0] = args;
52298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52299 if (!SWIG_IsOK(res1)) {
52300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52301 }
52302 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52303 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52305 return resultobj;
52306 fail:
52307 return NULL;
52308 }
52309
52310
52311 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52312 PyObject *resultobj = 0;
52313 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52314 wxIndividualLayoutConstraint *result = 0 ;
52315 void *argp1 = 0 ;
52316 int res1 = 0 ;
52317 PyObject *swig_obj[1] ;
52318
52319 if (!args) SWIG_fail;
52320 swig_obj[0] = args;
52321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52324 }
52325 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52326 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52328 return resultobj;
52329 fail:
52330 return NULL;
52331 }
52332
52333
52334 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52335 PyObject *resultobj = 0;
52336 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52337 wxIndividualLayoutConstraint *result = 0 ;
52338 void *argp1 = 0 ;
52339 int res1 = 0 ;
52340 PyObject *swig_obj[1] ;
52341
52342 if (!args) SWIG_fail;
52343 swig_obj[0] = args;
52344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52345 if (!SWIG_IsOK(res1)) {
52346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52347 }
52348 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52349 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52351 return resultobj;
52352 fail:
52353 return NULL;
52354 }
52355
52356
52357 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52358 PyObject *resultobj = 0;
52359 wxLayoutConstraints *result = 0 ;
52360
52361 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52362 {
52363 PyThreadState* __tstate = wxPyBeginAllowThreads();
52364 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52365 wxPyEndAllowThreads(__tstate);
52366 if (PyErr_Occurred()) SWIG_fail;
52367 }
52368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52369 return resultobj;
52370 fail:
52371 return NULL;
52372 }
52373
52374
52375 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52376 PyObject *resultobj = 0;
52377 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 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_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52385 if (!SWIG_IsOK(res1)) {
52386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52387 }
52388 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52389 {
52390 PyThreadState* __tstate = wxPyBeginAllowThreads();
52391 delete arg1;
52392
52393 wxPyEndAllowThreads(__tstate);
52394 if (PyErr_Occurred()) SWIG_fail;
52395 }
52396 resultobj = SWIG_Py_Void();
52397 return resultobj;
52398 fail:
52399 return NULL;
52400 }
52401
52402
52403 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52404 PyObject *resultobj = 0;
52405 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52406 wxWindow *arg2 = (wxWindow *) 0 ;
52407 int *arg3 = (int *) 0 ;
52408 bool result;
52409 void *argp1 = 0 ;
52410 int res1 = 0 ;
52411 void *argp2 = 0 ;
52412 int res2 = 0 ;
52413 int temp3 ;
52414 int res3 = SWIG_TMPOBJ ;
52415 PyObject * obj0 = 0 ;
52416 PyObject * obj1 = 0 ;
52417 char * kwnames[] = {
52418 (char *) "self",(char *) "win", NULL
52419 };
52420
52421 arg3 = &temp3;
52422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52424 if (!SWIG_IsOK(res1)) {
52425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52426 }
52427 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52429 if (!SWIG_IsOK(res2)) {
52430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52431 }
52432 arg2 = reinterpret_cast< wxWindow * >(argp2);
52433 {
52434 PyThreadState* __tstate = wxPyBeginAllowThreads();
52435 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52436 wxPyEndAllowThreads(__tstate);
52437 if (PyErr_Occurred()) SWIG_fail;
52438 }
52439 {
52440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52441 }
52442 if (SWIG_IsTmpObj(res3)) {
52443 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52444 } else {
52445 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52447 }
52448 return resultobj;
52449 fail:
52450 return NULL;
52451 }
52452
52453
52454 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52455 PyObject *resultobj = 0;
52456 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52457 bool result;
52458 void *argp1 = 0 ;
52459 int res1 = 0 ;
52460 PyObject *swig_obj[1] ;
52461
52462 if (!args) SWIG_fail;
52463 swig_obj[0] = args;
52464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52465 if (!SWIG_IsOK(res1)) {
52466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52467 }
52468 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52469 {
52470 PyThreadState* __tstate = wxPyBeginAllowThreads();
52471 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52472 wxPyEndAllowThreads(__tstate);
52473 if (PyErr_Occurred()) SWIG_fail;
52474 }
52475 {
52476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52477 }
52478 return resultobj;
52479 fail:
52480 return NULL;
52481 }
52482
52483
52484 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52485 PyObject *obj;
52486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52487 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52488 return SWIG_Py_Void();
52489 }
52490
52491 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52492 return SWIG_Python_InitShadowInstance(args);
52493 }
52494
52495 static PyMethodDef SwigMethods[] = {
52496 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52497 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52498 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52499 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52500 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52501 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52502 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52503 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52504 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52506 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52516 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52517 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52518 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52520 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52521 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52522 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52523 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52524 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52525 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52526 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52528 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52534 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52535 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52536 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52537 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52538 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52539 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52540 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52542 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52550 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52551 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52552 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52557 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52558 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52560 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52562 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52564 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52566 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52568 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52570 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52571 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52573 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52575 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52576 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52577 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52578 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52590 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52592 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52597 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52598 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52599 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52600 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52601 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52602 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52603 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52604 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52606 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52607 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52608 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52613 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52614 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52615 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52616 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52623 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52630 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52631 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52632 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52633 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52635 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52636 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52637 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52639 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52640 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52641 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52642 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52647 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52648 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52649 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52650 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52651 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52652 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52655 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52656 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52657 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52659 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52660 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52662 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52663 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52664 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52665 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52666 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52667 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52668 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52669 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52670 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52671 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52672 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52677 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52683 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52684 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52685 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52686 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52688 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52691 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52693 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52696 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52697 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52698 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52701 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52702 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52703 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52707 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52708 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52709 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52713 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52718 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52719 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52720 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52721 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52722 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52723 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52724 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52730 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52731 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52733 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52734 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52735 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52741 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52742 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52744 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52745 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52746 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52747 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52748 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52749 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52750 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52751 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52753 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52754 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52755 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52756 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52757 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52758 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52759 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52760 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52762 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52771 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52783 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52784 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52799 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52800 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52801 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52802 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52805 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52807 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52809 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52811 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52813 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52816 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52817 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52818 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52819 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52821 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52838 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52839 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52845 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52846 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52847 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52848 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52849 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52850 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52851 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52852 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52853 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52854 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52855 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52856 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52857 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52858 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52859 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52860 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52861 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52862 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52863 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52864 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52865 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52866 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52867 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52868 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52869 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52870 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52871 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52872 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52873 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52874 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52875 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52876 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52877 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52878 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52879 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52881 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52882 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52883 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52884 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52887 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52891 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52895 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52896 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52897 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52898 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52900 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52901 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52903 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52905 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52907 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52909 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52910 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52911 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52913 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52914 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52916 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52917 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52918 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52920 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52921 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52922 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52924 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52926 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52927 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52928 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52930 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52932 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52933 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52935 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52936 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52937 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52939 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52940 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52941 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52942 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52943 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52945 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52946 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52949 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52952 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52953 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52956 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52957 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52959 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52965 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52966 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52967 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52968 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52969 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52970 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52971 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52972 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52973 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52974 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52975 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52976 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52977 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52978 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52979 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52980 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52981 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52982 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52983 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52984 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52985 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52986 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52987 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52988 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52990 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52991 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52992 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52993 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52994 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52995 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52996 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52997 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52998 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52999 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53000 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53001 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53002 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53003 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53004 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53005 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53006 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53007 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53008 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53009 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53010 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53011 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53012 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53013 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53014 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53015 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53016 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53017 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53018 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53019 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53020 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53021 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53023 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53024 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53026 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53027 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53028 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53031 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53032 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53033 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53034 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53035 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53036 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53037 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53038 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53039 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53040 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53041 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53042 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53043 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53044 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53045 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53046 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53047 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53048 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53049 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53050 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53051 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53052 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53053 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53054 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53055 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53056 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53057 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53058 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53059 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53060 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53061 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53062 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53063 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53064 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53065 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53066 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53067 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53069 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53070 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53073 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53074 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53075 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53076 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53077 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53078 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53080 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53081 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53084 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53087 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53088 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53090 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53091 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53093 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53094 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53095 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53097 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53099 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53100 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53102 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53103 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53104 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53106 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53107 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53110 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53111 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53113 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53114 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53115 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53116 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53117 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53120 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53122 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53124 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53125 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53126 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53129 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53130 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53131 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53133 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53134 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53135 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53137 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53138 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53139 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53140 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53141 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53142 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53144 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53145 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53146 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53147 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53148 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53149 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53150 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53151 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53157 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53159 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53161 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53162 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53163 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53164 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53165 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53166 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53168 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53169 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53170 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53171 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53172 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53173 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53176 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53177 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53178 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53181 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53182 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53184 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53185 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53187 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53189 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53192 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53194 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53197 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53198 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53201 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53202 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53203 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53205 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53207 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53208 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53209 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53211 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53213 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53215 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53216 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53218 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53220 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53221 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53222 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53224 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53226 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53227 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53228 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53230 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53232 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53233 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53234 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53235 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53237 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53239 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53241 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53243 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53244 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53246 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53247 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53248 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53249 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53250 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53251 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53252 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53253 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53255 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53257 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53259 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53261 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53263 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53265 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53266 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53267 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53268 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53269 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53270 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53276 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53277 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53278 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53279 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53280 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53281 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53282 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53284 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53286 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53287 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53289 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53290 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53291 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53292 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53294 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53295 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53296 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53297 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53299 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53300 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53302 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53303 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53304 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53306 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53308 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53309 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53310 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53311 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53312 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53314 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53315 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53316 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53317 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53319 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53320 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53321 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53322 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53323 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53324 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53325 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53326 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53327 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53328 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53330 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53333 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53334 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53335 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53337 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53339 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53341 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53343 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53344 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53354 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53355 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53359 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53360 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53361 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53362 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53363 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53364 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53365 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53366 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53367 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53368 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53369 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53370 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53371 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53372 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53373 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53375 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53376 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53379 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53380 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53385 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53386 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53389 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53390 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53391 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53392 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53395 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53396 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53397 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53399 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53401 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53402 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53403 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53405 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53407 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53409 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53412 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53413 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53414 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53415 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53416 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53417 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53418 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53424 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53425 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53426 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53427 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53433 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53439 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53440 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53441 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53442 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53443 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53445 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53455 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53456 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53457 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53458 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53461 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53462 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53463 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53464 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53466 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53467 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53471 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53477 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53478 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53479 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53480 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53482 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53483 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53485 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53488 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53490 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53491 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53492 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53501 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53505 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53507 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53518 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53519 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53520 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53521 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53524 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53527 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53529 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53532 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53534 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53535 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53538 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53540 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53541 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53542 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53543 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53544 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53549 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53550 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53551 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53553 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53554 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53555 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53557 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53559 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53560 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53561 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53563 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53564 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53567 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53575 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53582 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53590 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53593 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53594 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53607 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53609 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53611 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53612 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53614 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53616 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53617 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53619 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53620 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53621 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53625 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53644 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53645 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53647 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53649 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53650 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53651 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53653 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53654 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53657 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53658 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53660 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53661 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53663 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53666 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53667 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53669 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53671 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53673 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53674 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53676 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53677 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53680 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53682 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53684 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53686 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53689 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53691 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53692 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53693 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53695 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53696 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53697 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53699 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53702 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53704 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53705 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53709 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53713 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53714 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53716 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53720 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53722 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53724 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53725 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53726 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53727 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53731 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53732 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53733 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53734 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53736 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53737 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53742 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53743 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53744 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53745 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53746 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53748 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53750 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53752 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53753 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53755 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53757 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53760 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53761 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53762 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53764 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53765 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53766 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53780 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53781 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53782 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53783 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53784 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53785 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53791 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53792 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53796 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53797 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53799 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53800 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53802 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53804 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53805 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53807 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53808 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53809 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53815 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53816 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53817 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53818 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53819 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53820 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53827 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53829 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53830 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53831 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53832 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53833 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53834 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53836 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53840 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53841 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53842 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53843 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53844 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53845 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53846 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53848 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53849 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53850 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53856 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53857 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53858 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53860 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53861 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53862 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53868 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53869 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53870 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53871 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53872 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53876 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53877 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53882 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53883 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53885 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53886 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53891 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53893 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53894 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53895 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53896 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53897 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53902 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53903 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53912 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53913 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53914 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53915 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53918 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53920 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53921 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53922 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53923 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53925 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53930 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53931 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53932 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53933 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53934 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53935 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53936 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53937 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53938 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53939 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53940 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53942 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53943 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53944 { NULL, NULL, 0, NULL }
53945 };
53946
53947
53948 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53949
53950 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53951 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53952 }
53953 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53954 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53955 }
53956 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53957 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53958 }
53959 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53960 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53961 }
53962 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53963 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53964 }
53965 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53966 return (void *)((wxSizer *) ((wxGridSizer *) x));
53967 }
53968 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53969 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53970 }
53971 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53972 return (void *)((wxSizer *) ((wxPySizer *) x));
53973 }
53974 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53975 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53976 }
53977 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53978 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53979 }
53980 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53981 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53982 }
53983 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53984 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53985 }
53986 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53987 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53988 }
53989 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53990 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53991 }
53992 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53993 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53994 }
53995 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53996 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53997 }
53998 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53999 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54000 }
54001 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54002 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54003 }
54004 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54005 return (void *)((wxEvent *) ((wxPyEvent *) x));
54006 }
54007 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54008 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54009 }
54010 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54011 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54012 }
54013 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54014 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54015 }
54016 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54017 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54018 }
54019 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54020 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54021 }
54022 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54023 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54024 }
54025 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54026 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54027 }
54028 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54029 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54030 }
54031 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54032 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54033 }
54034 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54035 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54036 }
54037 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54038 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54039 }
54040 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54041 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54042 }
54043 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54044 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54045 }
54046 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54047 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54048 }
54049 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54050 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54051 }
54052 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54053 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54054 }
54055 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54056 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54057 }
54058 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54059 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54060 }
54061 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54062 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54063 }
54064 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54065 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54066 }
54067 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54068 return (void *)((wxEvent *) ((wxShowEvent *) x));
54069 }
54070 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54071 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54072 }
54073 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54074 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54075 }
54076 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54077 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54078 }
54079 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54080 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54081 }
54082 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54083 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54084 }
54085 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54086 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54087 }
54088 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54089 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54090 }
54091 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54092 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54093 }
54094 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54095 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54096 }
54097 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54098 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54099 }
54100 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54101 return (void *)((wxControl *) ((wxControlWithItems *) x));
54102 }
54103 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54104 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54105 }
54106 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54107 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54108 }
54109 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54110 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54111 }
54112 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54113 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54114 }
54115 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54116 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54117 }
54118 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54119 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54120 }
54121 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54122 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54123 }
54124 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54125 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54126 }
54127 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54128 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54129 }
54130 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54131 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54132 }
54133 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54134 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54135 }
54136 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54137 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54138 }
54139 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54140 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54141 }
54142 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54143 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54144 }
54145 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54146 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54147 }
54148 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54149 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54150 }
54151 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54152 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54153 }
54154 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54155 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54156 }
54157 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54158 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54159 }
54160 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54161 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54162 }
54163 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54164 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54165 }
54166 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54167 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54168 }
54169 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54170 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54171 }
54172 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54173 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54174 }
54175 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54176 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54177 }
54178 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54179 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54180 }
54181 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54182 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54183 }
54184 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54185 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54186 }
54187 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54188 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54189 }
54190 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54191 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54192 }
54193 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54194 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54195 }
54196 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54197 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54198 }
54199 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54200 return (void *)((wxObject *) ((wxSizerItem *) x));
54201 }
54202 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54203 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54204 }
54205 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54206 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54207 }
54208 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54209 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54210 }
54211 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54212 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54213 }
54214 static void *_p_wxSizerTo_p_wxObject(void *x) {
54215 return (void *)((wxObject *) ((wxSizer *) x));
54216 }
54217 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54218 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54219 }
54220 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54221 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54222 }
54223 static void *_p_wxEventTo_p_wxObject(void *x) {
54224 return (void *)((wxObject *) ((wxEvent *) x));
54225 }
54226 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54227 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54228 }
54229 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54230 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54231 }
54232 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54233 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54234 }
54235 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54236 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54237 }
54238 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54239 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54240 }
54241 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54242 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54243 }
54244 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54245 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54246 }
54247 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54248 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54249 }
54250 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54251 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54252 }
54253 static void *_p_wxControlTo_p_wxObject(void *x) {
54254 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54255 }
54256 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54257 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54258 }
54259 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54260 return (void *)((wxObject *) ((wxFSFile *) x));
54261 }
54262 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54263 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54264 }
54265 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54266 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54267 }
54268 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54269 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54270 }
54271 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54272 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54273 }
54274 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54275 return (void *)((wxObject *) ((wxMenuItem *) x));
54276 }
54277 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54278 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54279 }
54280 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54281 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54282 }
54283 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54284 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54285 }
54286 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54287 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54288 }
54289 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54290 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54291 }
54292 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54293 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54294 }
54295 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54296 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54297 }
54298 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54299 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54300 }
54301 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54302 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54303 }
54304 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54305 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54306 }
54307 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54308 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54309 }
54310 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54311 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54312 }
54313 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54314 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54315 }
54316 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54317 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54318 }
54319 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54320 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54321 }
54322 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54323 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54324 }
54325 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54326 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54327 }
54328 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54329 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54330 }
54331 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54332 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54333 }
54334 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54335 return (void *)((wxObject *) ((wxImageHandler *) x));
54336 }
54337 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54338 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54339 }
54340 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54341 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54342 }
54343 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54344 return (void *)((wxObject *) ((wxEvtHandler *) x));
54345 }
54346 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54347 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54348 }
54349 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54350 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54351 }
54352 static void *_p_wxImageTo_p_wxObject(void *x) {
54353 return (void *)((wxObject *) ((wxImage *) x));
54354 }
54355 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54356 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54357 }
54358 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54359 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54360 }
54361 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54362 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54363 }
54364 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54365 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54366 }
54367 static void *_p_wxWindowTo_p_wxObject(void *x) {
54368 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54369 }
54370 static void *_p_wxMenuTo_p_wxObject(void *x) {
54371 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54372 }
54373 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54374 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54375 }
54376 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54377 return (void *)((wxObject *) ((wxFileSystem *) x));
54378 }
54379 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54380 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54381 }
54382 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54383 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54384 }
54385 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54386 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54387 }
54388 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54389 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54390 }
54391 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54392 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54393 }
54394 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54395 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54396 }
54397 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54398 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54399 }
54400 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54401 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54402 }
54403 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54404 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54405 }
54406 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54407 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54408 }
54409 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54410 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54411 }
54412 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54413 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54414 }
54415 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54416 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54417 }
54418 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54419 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54420 }
54421 static void *_p_wxControlTo_p_wxWindow(void *x) {
54422 return (void *)((wxWindow *) ((wxControl *) x));
54423 }
54424 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54425 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54426 }
54427 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54428 return (void *)((wxWindow *) ((wxMenuBar *) x));
54429 }
54430 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54431 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54432 }
54433 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54434 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54435 }
54436 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54437 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54438 }
54439 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54440 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54441 }
54442 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54443 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54444 }
54445 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54446 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54447 }
54448 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54449 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54450 }
54451 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54452 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54453 }
54454 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54455 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54456 }
54457 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54458 return (void *)((wxValidator *) ((wxPyValidator *) x));
54459 }
54460 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54462 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};
54463 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54488 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54489 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54490 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54491 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54492 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54493 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54494 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54495 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54496 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54497 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54498 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54499 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54500 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54501 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54503 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54589
54590 static swig_type_info *swig_type_initial[] = {
54591 &_swigt__p_buffer,
54592 &_swigt__p_char,
54593 &_swigt__p_form_ops_t,
54594 &_swigt__p_int,
54595 &_swigt__p_long,
54596 &_swigt__p_unsigned_char,
54597 &_swigt__p_unsigned_int,
54598 &_swigt__p_unsigned_long,
54599 &_swigt__p_wxANIHandler,
54600 &_swigt__p_wxAcceleratorEntry,
54601 &_swigt__p_wxAcceleratorTable,
54602 &_swigt__p_wxActivateEvent,
54603 &_swigt__p_wxAppTraits,
54604 &_swigt__p_wxArrayString,
54605 &_swigt__p_wxBMPHandler,
54606 &_swigt__p_wxBitmap,
54607 &_swigt__p_wxBoxSizer,
54608 &_swigt__p_wxButton,
54609 &_swigt__p_wxCURHandler,
54610 &_swigt__p_wxCaret,
54611 &_swigt__p_wxChildFocusEvent,
54612 &_swigt__p_wxCloseEvent,
54613 &_swigt__p_wxColour,
54614 &_swigt__p_wxCommandEvent,
54615 &_swigt__p_wxContextMenuEvent,
54616 &_swigt__p_wxControl,
54617 &_swigt__p_wxControlWithItems,
54618 &_swigt__p_wxCursor,
54619 &_swigt__p_wxDC,
54620 &_swigt__p_wxDateEvent,
54621 &_swigt__p_wxDateTime,
54622 &_swigt__p_wxDisplayChangedEvent,
54623 &_swigt__p_wxDropFilesEvent,
54624 &_swigt__p_wxDuplexMode,
54625 &_swigt__p_wxEraseEvent,
54626 &_swigt__p_wxEvent,
54627 &_swigt__p_wxEventLoop,
54628 &_swigt__p_wxEventLoopActivator,
54629 &_swigt__p_wxEvtHandler,
54630 &_swigt__p_wxFSFile,
54631 &_swigt__p_wxFileSystem,
54632 &_swigt__p_wxFileSystemHandler,
54633 &_swigt__p_wxFlexGridSizer,
54634 &_swigt__p_wxFocusEvent,
54635 &_swigt__p_wxFont,
54636 &_swigt__p_wxFrame,
54637 &_swigt__p_wxGBPosition,
54638 &_swigt__p_wxGBSizerItem,
54639 &_swigt__p_wxGBSpan,
54640 &_swigt__p_wxGIFHandler,
54641 &_swigt__p_wxGridBagSizer,
54642 &_swigt__p_wxGridSizer,
54643 &_swigt__p_wxICOHandler,
54644 &_swigt__p_wxIconizeEvent,
54645 &_swigt__p_wxIdleEvent,
54646 &_swigt__p_wxImage,
54647 &_swigt__p_wxImageHandler,
54648 &_swigt__p_wxImageHistogram,
54649 &_swigt__p_wxImage_HSVValue,
54650 &_swigt__p_wxImage_RGBValue,
54651 &_swigt__p_wxIndividualLayoutConstraint,
54652 &_swigt__p_wxInitDialogEvent,
54653 &_swigt__p_wxInputStream,
54654 &_swigt__p_wxInternetFSHandler,
54655 &_swigt__p_wxItemContainer,
54656 &_swigt__p_wxJPEGHandler,
54657 &_swigt__p_wxKeyEvent,
54658 &_swigt__p_wxLayoutConstraints,
54659 &_swigt__p_wxMaximizeEvent,
54660 &_swigt__p_wxMemoryFSHandler,
54661 &_swigt__p_wxMenu,
54662 &_swigt__p_wxMenuBar,
54663 &_swigt__p_wxMenuBarBase,
54664 &_swigt__p_wxMenuEvent,
54665 &_swigt__p_wxMenuItem,
54666 &_swigt__p_wxMouseCaptureChangedEvent,
54667 &_swigt__p_wxMouseEvent,
54668 &_swigt__p_wxMoveEvent,
54669 &_swigt__p_wxNavigationKeyEvent,
54670 &_swigt__p_wxNcPaintEvent,
54671 &_swigt__p_wxNotifyEvent,
54672 &_swigt__p_wxObject,
54673 &_swigt__p_wxOutputStream,
54674 &_swigt__p_wxPCXHandler,
54675 &_swigt__p_wxPNGHandler,
54676 &_swigt__p_wxPNMHandler,
54677 &_swigt__p_wxPaintEvent,
54678 &_swigt__p_wxPaletteChangedEvent,
54679 &_swigt__p_wxPaperSize,
54680 &_swigt__p_wxPoint,
54681 &_swigt__p_wxPoint2D,
54682 &_swigt__p_wxPropagateOnce,
54683 &_swigt__p_wxPropagationDisabler,
54684 &_swigt__p_wxPyApp,
54685 &_swigt__p_wxPyCommandEvent,
54686 &_swigt__p_wxPyDropTarget,
54687 &_swigt__p_wxPyEvent,
54688 &_swigt__p_wxPyFileSystemHandler,
54689 &_swigt__p_wxPyImageHandler,
54690 &_swigt__p_wxPyInputStream,
54691 &_swigt__p_wxPySizer,
54692 &_swigt__p_wxPyValidator,
54693 &_swigt__p_wxQuantize,
54694 &_swigt__p_wxQueryNewPaletteEvent,
54695 &_swigt__p_wxRealPoint,
54696 &_swigt__p_wxRect,
54697 &_swigt__p_wxRegion,
54698 &_swigt__p_wxScrollEvent,
54699 &_swigt__p_wxScrollWinEvent,
54700 &_swigt__p_wxSetCursorEvent,
54701 &_swigt__p_wxShowEvent,
54702 &_swigt__p_wxSize,
54703 &_swigt__p_wxSizeEvent,
54704 &_swigt__p_wxSizer,
54705 &_swigt__p_wxSizerItem,
54706 &_swigt__p_wxStaticBox,
54707 &_swigt__p_wxStaticBoxSizer,
54708 &_swigt__p_wxStdDialogButtonSizer,
54709 &_swigt__p_wxSysColourChangedEvent,
54710 &_swigt__p_wxTIFFHandler,
54711 &_swigt__p_wxToolTip,
54712 &_swigt__p_wxUpdateUIEvent,
54713 &_swigt__p_wxValidator,
54714 &_swigt__p_wxVisualAttributes,
54715 &_swigt__p_wxWindow,
54716 &_swigt__p_wxWindowCreateEvent,
54717 &_swigt__p_wxWindowDestroyEvent,
54718 &_swigt__p_wxXPMHandler,
54719 &_swigt__p_wxZipFSHandler,
54720 };
54721
54722 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54723 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54733 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54734 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54735 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54736 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}};
54737 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54738 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}};
54739 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54740 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}};
54741 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54742 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54743 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54744 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54745 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_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}};
54746 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54747 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}};
54748 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54749 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54750 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54751 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54752 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54753 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54754 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54755 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54756 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54757 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
54758 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54759 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54760 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}};
54761 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54762 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54763 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}};
54764 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}};
54765 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54766 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54773 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}};
54774 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}};
54775 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54776 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54777 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_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},{0, 0, 0, 0}};
54779 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54780 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54781 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54782 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54783 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54784 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54785 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54786 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}};
54787 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54788 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54791 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54792 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxEvtHandler, _p_wxEvtHandlerTo_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
54804 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54805 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54809 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54810 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54811 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54819 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54820 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54821 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54822 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54823 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54824 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54828 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54829 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54830 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54831 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54832 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54833 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54835 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}};
54836 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}};
54837 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54842 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54844 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}};
54845 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54846 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}};
54847 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54848 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54849 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54850 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54851
54852 static swig_cast_info *swig_cast_initial[] = {
54853 _swigc__p_buffer,
54854 _swigc__p_char,
54855 _swigc__p_form_ops_t,
54856 _swigc__p_int,
54857 _swigc__p_long,
54858 _swigc__p_unsigned_char,
54859 _swigc__p_unsigned_int,
54860 _swigc__p_unsigned_long,
54861 _swigc__p_wxANIHandler,
54862 _swigc__p_wxAcceleratorEntry,
54863 _swigc__p_wxAcceleratorTable,
54864 _swigc__p_wxActivateEvent,
54865 _swigc__p_wxAppTraits,
54866 _swigc__p_wxArrayString,
54867 _swigc__p_wxBMPHandler,
54868 _swigc__p_wxBitmap,
54869 _swigc__p_wxBoxSizer,
54870 _swigc__p_wxButton,
54871 _swigc__p_wxCURHandler,
54872 _swigc__p_wxCaret,
54873 _swigc__p_wxChildFocusEvent,
54874 _swigc__p_wxCloseEvent,
54875 _swigc__p_wxColour,
54876 _swigc__p_wxCommandEvent,
54877 _swigc__p_wxContextMenuEvent,
54878 _swigc__p_wxControl,
54879 _swigc__p_wxControlWithItems,
54880 _swigc__p_wxCursor,
54881 _swigc__p_wxDC,
54882 _swigc__p_wxDateEvent,
54883 _swigc__p_wxDateTime,
54884 _swigc__p_wxDisplayChangedEvent,
54885 _swigc__p_wxDropFilesEvent,
54886 _swigc__p_wxDuplexMode,
54887 _swigc__p_wxEraseEvent,
54888 _swigc__p_wxEvent,
54889 _swigc__p_wxEventLoop,
54890 _swigc__p_wxEventLoopActivator,
54891 _swigc__p_wxEvtHandler,
54892 _swigc__p_wxFSFile,
54893 _swigc__p_wxFileSystem,
54894 _swigc__p_wxFileSystemHandler,
54895 _swigc__p_wxFlexGridSizer,
54896 _swigc__p_wxFocusEvent,
54897 _swigc__p_wxFont,
54898 _swigc__p_wxFrame,
54899 _swigc__p_wxGBPosition,
54900 _swigc__p_wxGBSizerItem,
54901 _swigc__p_wxGBSpan,
54902 _swigc__p_wxGIFHandler,
54903 _swigc__p_wxGridBagSizer,
54904 _swigc__p_wxGridSizer,
54905 _swigc__p_wxICOHandler,
54906 _swigc__p_wxIconizeEvent,
54907 _swigc__p_wxIdleEvent,
54908 _swigc__p_wxImage,
54909 _swigc__p_wxImageHandler,
54910 _swigc__p_wxImageHistogram,
54911 _swigc__p_wxImage_HSVValue,
54912 _swigc__p_wxImage_RGBValue,
54913 _swigc__p_wxIndividualLayoutConstraint,
54914 _swigc__p_wxInitDialogEvent,
54915 _swigc__p_wxInputStream,
54916 _swigc__p_wxInternetFSHandler,
54917 _swigc__p_wxItemContainer,
54918 _swigc__p_wxJPEGHandler,
54919 _swigc__p_wxKeyEvent,
54920 _swigc__p_wxLayoutConstraints,
54921 _swigc__p_wxMaximizeEvent,
54922 _swigc__p_wxMemoryFSHandler,
54923 _swigc__p_wxMenu,
54924 _swigc__p_wxMenuBar,
54925 _swigc__p_wxMenuBarBase,
54926 _swigc__p_wxMenuEvent,
54927 _swigc__p_wxMenuItem,
54928 _swigc__p_wxMouseCaptureChangedEvent,
54929 _swigc__p_wxMouseEvent,
54930 _swigc__p_wxMoveEvent,
54931 _swigc__p_wxNavigationKeyEvent,
54932 _swigc__p_wxNcPaintEvent,
54933 _swigc__p_wxNotifyEvent,
54934 _swigc__p_wxObject,
54935 _swigc__p_wxOutputStream,
54936 _swigc__p_wxPCXHandler,
54937 _swigc__p_wxPNGHandler,
54938 _swigc__p_wxPNMHandler,
54939 _swigc__p_wxPaintEvent,
54940 _swigc__p_wxPaletteChangedEvent,
54941 _swigc__p_wxPaperSize,
54942 _swigc__p_wxPoint,
54943 _swigc__p_wxPoint2D,
54944 _swigc__p_wxPropagateOnce,
54945 _swigc__p_wxPropagationDisabler,
54946 _swigc__p_wxPyApp,
54947 _swigc__p_wxPyCommandEvent,
54948 _swigc__p_wxPyDropTarget,
54949 _swigc__p_wxPyEvent,
54950 _swigc__p_wxPyFileSystemHandler,
54951 _swigc__p_wxPyImageHandler,
54952 _swigc__p_wxPyInputStream,
54953 _swigc__p_wxPySizer,
54954 _swigc__p_wxPyValidator,
54955 _swigc__p_wxQuantize,
54956 _swigc__p_wxQueryNewPaletteEvent,
54957 _swigc__p_wxRealPoint,
54958 _swigc__p_wxRect,
54959 _swigc__p_wxRegion,
54960 _swigc__p_wxScrollEvent,
54961 _swigc__p_wxScrollWinEvent,
54962 _swigc__p_wxSetCursorEvent,
54963 _swigc__p_wxShowEvent,
54964 _swigc__p_wxSize,
54965 _swigc__p_wxSizeEvent,
54966 _swigc__p_wxSizer,
54967 _swigc__p_wxSizerItem,
54968 _swigc__p_wxStaticBox,
54969 _swigc__p_wxStaticBoxSizer,
54970 _swigc__p_wxStdDialogButtonSizer,
54971 _swigc__p_wxSysColourChangedEvent,
54972 _swigc__p_wxTIFFHandler,
54973 _swigc__p_wxToolTip,
54974 _swigc__p_wxUpdateUIEvent,
54975 _swigc__p_wxValidator,
54976 _swigc__p_wxVisualAttributes,
54977 _swigc__p_wxWindow,
54978 _swigc__p_wxWindowCreateEvent,
54979 _swigc__p_wxWindowDestroyEvent,
54980 _swigc__p_wxXPMHandler,
54981 _swigc__p_wxZipFSHandler,
54982 };
54983
54984
54985 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54986
54987 static swig_const_info swig_const_table[] = {
54988 {0, 0, 0, 0.0, 0, 0}};
54989
54990 #ifdef __cplusplus
54991 }
54992 #endif
54993 /* -----------------------------------------------------------------------------
54994 * Type initialization:
54995 * This problem is tough by the requirement that no dynamic
54996 * memory is used. Also, since swig_type_info structures store pointers to
54997 * swig_cast_info structures and swig_cast_info structures store pointers back
54998 * to swig_type_info structures, we need some lookup code at initialization.
54999 * The idea is that swig generates all the structures that are needed.
55000 * The runtime then collects these partially filled structures.
55001 * The SWIG_InitializeModule function takes these initial arrays out of
55002 * swig_module, and does all the lookup, filling in the swig_module.types
55003 * array with the correct data and linking the correct swig_cast_info
55004 * structures together.
55005 *
55006 * The generated swig_type_info structures are assigned staticly to an initial
55007 * array. We just loop though that array, and handle each type individually.
55008 * First we lookup if this type has been already loaded, and if so, use the
55009 * loaded structure instead of the generated one. Then we have to fill in the
55010 * cast linked list. The cast data is initially stored in something like a
55011 * two-dimensional array. Each row corresponds to a type (there are the same
55012 * number of rows as there are in the swig_type_initial array). Each entry in
55013 * a column is one of the swig_cast_info structures for that type.
55014 * The cast_initial array is actually an array of arrays, because each row has
55015 * a variable number of columns. So to actually build the cast linked list,
55016 * we find the array of casts associated with the type, and loop through it
55017 * adding the casts to the list. The one last trick we need to do is making
55018 * sure the type pointer in the swig_cast_info struct is correct.
55019 *
55020 * First off, we lookup the cast->type name to see if it is already loaded.
55021 * There are three cases to handle:
55022 * 1) If the cast->type has already been loaded AND the type we are adding
55023 * casting info to has not been loaded (it is in this module), THEN we
55024 * replace the cast->type pointer with the type pointer that has already
55025 * been loaded.
55026 * 2) If BOTH types (the one we are adding casting info to, and the
55027 * cast->type) are loaded, THEN the cast info has already been loaded by
55028 * the previous module so we just ignore it.
55029 * 3) Finally, if cast->type has not already been loaded, then we add that
55030 * swig_cast_info to the linked list (because the cast->type) pointer will
55031 * be correct.
55032 * ----------------------------------------------------------------------------- */
55033
55034 #ifdef __cplusplus
55035 extern "C" {
55036 #if 0
55037 } /* c-mode */
55038 #endif
55039 #endif
55040
55041 #if 0
55042 #define SWIGRUNTIME_DEBUG
55043 #endif
55044
55045 SWIGRUNTIME void
55046 SWIG_InitializeModule(void *clientdata) {
55047 size_t i;
55048 swig_module_info *module_head;
55049 static int init_run = 0;
55050
55051 clientdata = clientdata;
55052
55053 if (init_run) return;
55054 init_run = 1;
55055
55056 /* Initialize the swig_module */
55057 swig_module.type_initial = swig_type_initial;
55058 swig_module.cast_initial = swig_cast_initial;
55059
55060 /* Try and load any already created modules */
55061 module_head = SWIG_GetModule(clientdata);
55062 if (module_head) {
55063 swig_module.next = module_head->next;
55064 module_head->next = &swig_module;
55065 } else {
55066 /* This is the first module loaded */
55067 swig_module.next = &swig_module;
55068 SWIG_SetModule(clientdata, &swig_module);
55069 }
55070
55071 /* Now work on filling in swig_module.types */
55072 #ifdef SWIGRUNTIME_DEBUG
55073 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55074 #endif
55075 for (i = 0; i < swig_module.size; ++i) {
55076 swig_type_info *type = 0;
55077 swig_type_info *ret;
55078 swig_cast_info *cast;
55079
55080 #ifdef SWIGRUNTIME_DEBUG
55081 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55082 #endif
55083
55084 /* if there is another module already loaded */
55085 if (swig_module.next != &swig_module) {
55086 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55087 }
55088 if (type) {
55089 /* Overwrite clientdata field */
55090 #ifdef SWIGRUNTIME_DEBUG
55091 printf("SWIG_InitializeModule: found type %s\n", type->name);
55092 #endif
55093 if (swig_module.type_initial[i]->clientdata) {
55094 type->clientdata = swig_module.type_initial[i]->clientdata;
55095 #ifdef SWIGRUNTIME_DEBUG
55096 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55097 #endif
55098 }
55099 } else {
55100 type = swig_module.type_initial[i];
55101 }
55102
55103 /* Insert casting types */
55104 cast = swig_module.cast_initial[i];
55105 while (cast->type) {
55106 /* Don't need to add information already in the list */
55107 ret = 0;
55108 #ifdef SWIGRUNTIME_DEBUG
55109 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55110 #endif
55111 if (swig_module.next != &swig_module) {
55112 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55113 #ifdef SWIGRUNTIME_DEBUG
55114 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55115 #endif
55116 }
55117 if (ret) {
55118 if (type == swig_module.type_initial[i]) {
55119 #ifdef SWIGRUNTIME_DEBUG
55120 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55121 #endif
55122 cast->type = ret;
55123 ret = 0;
55124 } else {
55125 /* Check for casting already in the list */
55126 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55127 #ifdef SWIGRUNTIME_DEBUG
55128 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55129 #endif
55130 if (!ocast) ret = 0;
55131 }
55132 }
55133
55134 if (!ret) {
55135 #ifdef SWIGRUNTIME_DEBUG
55136 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55137 #endif
55138 if (type->cast) {
55139 type->cast->prev = cast;
55140 cast->next = type->cast;
55141 }
55142 type->cast = cast;
55143 }
55144 cast++;
55145 }
55146 /* Set entry in modules->types array equal to the type */
55147 swig_module.types[i] = type;
55148 }
55149 swig_module.types[i] = 0;
55150
55151 #ifdef SWIGRUNTIME_DEBUG
55152 printf("**** SWIG_InitializeModule: Cast List ******\n");
55153 for (i = 0; i < swig_module.size; ++i) {
55154 int j = 0;
55155 swig_cast_info *cast = swig_module.cast_initial[i];
55156 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55157 while (cast->type) {
55158 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55159 cast++;
55160 ++j;
55161 }
55162 printf("---- Total casts: %d\n",j);
55163 }
55164 printf("**** SWIG_InitializeModule: Cast List ******\n");
55165 #endif
55166 }
55167
55168 /* This function will propagate the clientdata field of type to
55169 * any new swig_type_info structures that have been added into the list
55170 * of equivalent types. It is like calling
55171 * SWIG_TypeClientData(type, clientdata) a second time.
55172 */
55173 SWIGRUNTIME void
55174 SWIG_PropagateClientData(void) {
55175 size_t i;
55176 swig_cast_info *equiv;
55177 static int init_run = 0;
55178
55179 if (init_run) return;
55180 init_run = 1;
55181
55182 for (i = 0; i < swig_module.size; i++) {
55183 if (swig_module.types[i]->clientdata) {
55184 equiv = swig_module.types[i]->cast;
55185 while (equiv) {
55186 if (!equiv->converter) {
55187 if (equiv->type && !equiv->type->clientdata)
55188 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55189 }
55190 equiv = equiv->next;
55191 }
55192 }
55193 }
55194 }
55195
55196 #ifdef __cplusplus
55197 #if 0
55198 {
55199 /* c-mode */
55200 #endif
55201 }
55202 #endif
55203
55204
55205
55206 #ifdef __cplusplus
55207 extern "C" {
55208 #endif
55209
55210 /* Python-specific SWIG API */
55211 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55212 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55213 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55214
55215 /* -----------------------------------------------------------------------------
55216 * global variable support code.
55217 * ----------------------------------------------------------------------------- */
55218
55219 typedef struct swig_globalvar {
55220 char *name; /* Name of global variable */
55221 PyObject *(*get_attr)(void); /* Return the current value */
55222 int (*set_attr)(PyObject *); /* Set the value */
55223 struct swig_globalvar *next;
55224 } swig_globalvar;
55225
55226 typedef struct swig_varlinkobject {
55227 PyObject_HEAD
55228 swig_globalvar *vars;
55229 } swig_varlinkobject;
55230
55231 SWIGINTERN PyObject *
55232 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55233 return PyString_FromString("<Swig global variables>");
55234 }
55235
55236 SWIGINTERN PyObject *
55237 swig_varlink_str(swig_varlinkobject *v) {
55238 PyObject *str = PyString_FromString("(");
55239 swig_globalvar *var;
55240 for (var = v->vars; var; var=var->next) {
55241 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55242 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55243 }
55244 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55245 return str;
55246 }
55247
55248 SWIGINTERN int
55249 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55250 PyObject *str = swig_varlink_str(v);
55251 fprintf(fp,"Swig global variables ");
55252 fprintf(fp,"%s\n", PyString_AsString(str));
55253 Py_DECREF(str);
55254 return 0;
55255 }
55256
55257 SWIGINTERN void
55258 swig_varlink_dealloc(swig_varlinkobject *v) {
55259 swig_globalvar *var = v->vars;
55260 while (var) {
55261 swig_globalvar *n = var->next;
55262 free(var->name);
55263 free(var);
55264 var = n;
55265 }
55266 }
55267
55268 SWIGINTERN PyObject *
55269 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55270 PyObject *res = NULL;
55271 swig_globalvar *var = v->vars;
55272 while (var) {
55273 if (strcmp(var->name,n) == 0) {
55274 res = (*var->get_attr)();
55275 break;
55276 }
55277 var = var->next;
55278 }
55279 if (res == NULL && !PyErr_Occurred()) {
55280 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55281 }
55282 return res;
55283 }
55284
55285 SWIGINTERN int
55286 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55287 int res = 1;
55288 swig_globalvar *var = v->vars;
55289 while (var) {
55290 if (strcmp(var->name,n) == 0) {
55291 res = (*var->set_attr)(p);
55292 break;
55293 }
55294 var = var->next;
55295 }
55296 if (res == 1 && !PyErr_Occurred()) {
55297 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55298 }
55299 return res;
55300 }
55301
55302 SWIGINTERN PyTypeObject*
55303 swig_varlink_type(void) {
55304 static char varlink__doc__[] = "Swig var link object";
55305 static PyTypeObject varlink_type;
55306 static int type_init = 0;
55307 if (!type_init) {
55308 const PyTypeObject tmp
55309 = {
55310 PyObject_HEAD_INIT(NULL)
55311 0, /* Number of items in variable part (ob_size) */
55312 (char *)"swigvarlink", /* Type name (tp_name) */
55313 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55314 0, /* Itemsize (tp_itemsize) */
55315 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55316 (printfunc) swig_varlink_print, /* Print (tp_print) */
55317 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55318 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55319 0, /* tp_compare */
55320 (reprfunc) swig_varlink_repr, /* tp_repr */
55321 0, /* tp_as_number */
55322 0, /* tp_as_sequence */
55323 0, /* tp_as_mapping */
55324 0, /* tp_hash */
55325 0, /* tp_call */
55326 (reprfunc)swig_varlink_str, /* tp_str */
55327 0, /* tp_getattro */
55328 0, /* tp_setattro */
55329 0, /* tp_as_buffer */
55330 0, /* tp_flags */
55331 varlink__doc__, /* tp_doc */
55332 0, /* tp_traverse */
55333 0, /* tp_clear */
55334 0, /* tp_richcompare */
55335 0, /* tp_weaklistoffset */
55336 #if PY_VERSION_HEX >= 0x02020000
55337 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55338 #endif
55339 #if PY_VERSION_HEX >= 0x02030000
55340 0, /* tp_del */
55341 #endif
55342 #ifdef COUNT_ALLOCS
55343 0,0,0,0 /* tp_alloc -> tp_next */
55344 #endif
55345 };
55346 varlink_type = tmp;
55347 varlink_type.ob_type = &PyType_Type;
55348 type_init = 1;
55349 }
55350 return &varlink_type;
55351 }
55352
55353 /* Create a variable linking object for use later */
55354 SWIGINTERN PyObject *
55355 SWIG_Python_newvarlink(void) {
55356 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55357 if (result) {
55358 result->vars = 0;
55359 }
55360 return ((PyObject*) result);
55361 }
55362
55363 SWIGINTERN void
55364 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55365 swig_varlinkobject *v = (swig_varlinkobject *) p;
55366 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55367 if (gv) {
55368 size_t size = strlen(name)+1;
55369 gv->name = (char *)malloc(size);
55370 if (gv->name) {
55371 strncpy(gv->name,name,size);
55372 gv->get_attr = get_attr;
55373 gv->set_attr = set_attr;
55374 gv->next = v->vars;
55375 }
55376 }
55377 v->vars = gv;
55378 }
55379
55380 SWIGINTERN PyObject *
55381 SWIG_globals() {
55382 static PyObject *_SWIG_globals = 0;
55383 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55384 return _SWIG_globals;
55385 }
55386
55387 /* -----------------------------------------------------------------------------
55388 * constants/methods manipulation
55389 * ----------------------------------------------------------------------------- */
55390
55391 /* Install Constants */
55392 SWIGINTERN void
55393 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55394 PyObject *obj = 0;
55395 size_t i;
55396 for (i = 0; constants[i].type; ++i) {
55397 switch(constants[i].type) {
55398 case SWIG_PY_POINTER:
55399 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55400 break;
55401 case SWIG_PY_BINARY:
55402 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55403 break;
55404 default:
55405 obj = 0;
55406 break;
55407 }
55408 if (obj) {
55409 PyDict_SetItemString(d, constants[i].name, obj);
55410 Py_DECREF(obj);
55411 }
55412 }
55413 }
55414
55415 /* -----------------------------------------------------------------------------*/
55416 /* Fix SwigMethods to carry the callback ptrs when needed */
55417 /* -----------------------------------------------------------------------------*/
55418
55419 SWIGINTERN void
55420 SWIG_Python_FixMethods(PyMethodDef *methods,
55421 swig_const_info *const_table,
55422 swig_type_info **types,
55423 swig_type_info **types_initial) {
55424 size_t i;
55425 for (i = 0; methods[i].ml_name; ++i) {
55426 char *c = methods[i].ml_doc;
55427 if (c && (c = strstr(c, "swig_ptr: "))) {
55428 int j;
55429 swig_const_info *ci = 0;
55430 char *name = c + 10;
55431 for (j = 0; const_table[j].type; ++j) {
55432 if (strncmp(const_table[j].name, name,
55433 strlen(const_table[j].name)) == 0) {
55434 ci = &(const_table[j]);
55435 break;
55436 }
55437 }
55438 if (ci) {
55439 size_t shift = (ci->ptype) - types;
55440 swig_type_info *ty = types_initial[shift];
55441 size_t ldoc = (c - methods[i].ml_doc);
55442 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55443 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55444 if (ndoc) {
55445 char *buff = ndoc;
55446 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55447 if (ptr) {
55448 strncpy(buff, methods[i].ml_doc, ldoc);
55449 buff += ldoc;
55450 strncpy(buff, "swig_ptr: ", 10);
55451 buff += 10;
55452 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55453 methods[i].ml_doc = ndoc;
55454 }
55455 }
55456 }
55457 }
55458 }
55459 }
55460
55461 #ifdef __cplusplus
55462 }
55463 #endif
55464
55465 /* -----------------------------------------------------------------------------*
55466 * Partial Init method
55467 * -----------------------------------------------------------------------------*/
55468
55469 #ifdef __cplusplus
55470 extern "C"
55471 #endif
55472 SWIGEXPORT void SWIG_init(void) {
55473 PyObject *m, *d;
55474
55475 /* Fix SwigMethods to carry the callback ptrs when needed */
55476 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55477
55478 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55479 d = PyModule_GetDict(m);
55480
55481 SWIG_InitializeModule(0);
55482 SWIG_InstallConstants(d,swig_const_table);
55483
55484
55485
55486 #ifndef wxPyUSE_EXPORT
55487 // Make our API structure a CObject so other modules can import it
55488 // from this module.
55489 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55490 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55491 Py_XDECREF(cobj);
55492 #endif
55493
55494 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55495 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55496 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55497 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55498 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55499 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55500 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55501 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55502 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55503 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55504 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55505 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55506 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55507 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55508 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55509 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55510 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55511 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55512 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55513 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55514 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55515 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55516 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55517 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55518 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55519 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55520 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55521 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55522 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55523 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55524 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55525 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55526 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55527 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55528 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55529 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55530 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55531 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55532 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55533 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55534 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55535 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55536 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55537 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55538 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55539 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55540 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55541 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55542 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55543 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55544 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55545 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55546 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55547 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55548 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55549 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55550 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55551 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55552 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55553 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55554 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55555 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55556 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55557 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55558 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55559 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55560 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55561 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55562 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55563 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55564 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55565 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55566 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55567 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55568 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55569 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55570 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55571 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55572 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55573 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55574 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55575 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55576 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55577 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55578 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55579 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55580 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55581 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55582 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55583 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55584 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55585 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55586 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55587 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55588 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55589 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55590 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55591 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55592 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55593 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55594 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55595 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55596 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55597 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55598 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55599 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55600 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55601 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55602 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55603 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55604 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55605 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55606 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55607 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55608 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55609 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55610 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55611 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55612 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55613 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55614 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55615 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55616 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55617 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55618 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55619 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55620 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55621 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55622 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55623 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55624 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55625 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55626 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55627 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55628 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55629 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55630 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55631 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55632 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55633 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55634 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55635 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55636 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55637 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55638 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55639 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55640 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55641 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55642 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55643 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55644 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55645 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55646 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55647 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55648 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55649 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55650 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55651 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55652 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55653 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55654 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55655 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55656 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55657 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55658 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55659 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55660 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55661 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55662 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55663 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55664 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55665 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55666 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55667 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55668 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55669 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55670 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55671 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55672 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55673 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55674 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55675 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55676 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55677 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55678 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55679 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55680 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55681 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55682 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55683 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55684 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55685 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55686 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55687 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55688 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55689 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55690 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55691 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55692 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55693 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55694 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55695 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55696 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55697 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55698 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55699 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55700 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55701 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55702 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55703 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55704 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55705 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55706 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55707 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55708 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55709 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55710 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55711 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55712 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55713 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55714 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55715 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55716 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55717 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55718 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55719 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55720 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55721 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55722 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55723 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55724 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55725 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55726 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55727 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55728 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55729 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55730 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55731 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55732 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55733 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55734 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55735 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55736 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55737 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55738 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55739 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55740 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55741 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55742 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55743 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55744 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55745 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55746 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55747 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55748 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55749 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55750 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55751 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55752 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55753 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55754 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55755 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55756 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55757 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55758 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55759 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55760 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55761 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55762 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55763 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55764 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55765 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55766 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55767 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55768 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55769 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55770 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55771 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55772 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55773 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55774 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55775 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55776 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55777 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55778 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55779 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55780 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55781 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55782 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55783 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55784 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55785 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55786 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55787 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55788 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55789 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55790 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55791 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55792 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55793 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55794 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55795 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55796 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55797 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55798 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55799 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55800 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55801 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55802 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55803 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55804 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55805 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55806 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55807 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55808 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55809 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55810 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55811 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55812 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55813 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55814 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55815 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55816 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55817 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55818 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55819 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55820 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55821 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55822 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55823 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55824 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55825 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55826 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55827 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55828 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55829 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55830 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55831 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55832 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55833 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55834 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55835 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55836 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55837 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55838 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55839 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55840 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55841 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55842 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55843 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55844 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55845 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55846 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55847 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55848 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55849 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55850 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55851 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55852 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55853 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55854 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55855 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55856 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55857 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55858 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55859 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55860 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55861 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55862 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55863 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55864 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55865 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55866 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55867 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55868 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55869 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55870 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55871 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55872 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55873 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55874 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55875 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55876 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55877 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55878 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55879 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55880 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55881 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55882 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55883 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55884 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55885 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55886 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55887 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55888 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55889 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55890 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55891 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55892 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55893 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55894 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55895 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55896 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55897 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55898 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55899 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55900 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55901 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55902 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55914 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55916 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55917 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55918 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55919 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55920 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55921 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55922 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55923 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55924 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55925 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55926 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55927 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55928 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55929 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55930 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55931 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55932 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55933 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55934 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55935 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55936 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55937 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55938 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55939 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55940 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55941 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55942 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55943 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55944 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55945 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55946 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55947 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55948 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55949 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55950 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55951 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55952 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55953 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55954 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55955 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55956 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55957 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55958 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55959 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55960 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55961 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55962 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55963 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55964 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55965 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55966 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55967 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55968 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55969 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55970 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55971 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55972 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55973 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55974 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55975 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55976 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55977 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55978 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55979 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55980 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55981 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55982 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55983 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55984 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55985 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55986 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55987 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55988 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55989 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55990 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55991 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55992 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55993 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55994 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55995 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55996 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55997 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55998 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55999 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56000 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56001 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56002 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56003 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56004 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56005 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56006 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56007 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56008 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56009 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56010 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56011 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56012 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56013 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56014 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56015 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56016 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56017 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56018 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56019 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56020 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56021 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56022 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56023 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56024 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56025 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56026 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56027 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56028 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56029 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56030 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56031 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56032 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56033 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56034 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56035 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56036 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56037 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56038 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56039 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56040 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56041 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56042 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56043 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56044 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56045 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56046 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56047 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56048 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56049 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56050 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56051 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56052 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56053 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56054 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56055 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56056 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56057 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56058 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56059 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56060 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56061 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56062 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56063 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56064 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56065 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56066 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56067 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56068 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56069 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56070 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56071 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56072 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56073 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56074 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56075 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56076 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56077 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56078 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56079 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56080 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56081 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56082 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56083 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56084 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56085 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56086 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56087 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56088 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56089 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56090 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56091 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56092 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56093 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56094 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56095 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56096 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56097 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56098 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56099 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56100 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56101 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56102 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56103 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56104 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56105 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56106 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56107 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56108 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56109 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56110 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56116 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56117 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56118 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56119 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56120 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56121 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56122 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56123 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56124 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56125 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56126 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56127 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56128 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56129 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56130 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56131 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56132 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56133 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56134 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56135 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56136 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56137 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56138 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56139 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56140 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56141 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56142 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56143 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56144 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56145 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56146 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56147 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56148 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56149 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56150 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56151 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56152 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56153 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56154 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56155 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56156 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56157 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56158 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56159 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56160 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56161 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56162 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56163 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56164 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56165
56166 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56167
56168
56169 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56170
56171 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56172 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56173 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56174 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56175 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56176 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56177 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56178 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56179 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56180 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56181 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56182 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56184 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56185 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56186 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56187 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56188 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56189 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56190 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56191 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56192 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56193 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56194 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56195 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56196 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56197 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56198 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56199 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56200 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56201 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56202 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56203 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56204 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56205 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56206 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56207 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56208 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56209 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56210 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56211 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56212 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56213 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56214 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56215 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56216 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56217 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56218 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56219 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56220 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56221 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56222 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56223 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56224 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56225 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56226 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56227 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56228 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56229 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56230 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56231 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56232 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56233 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56234 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56235 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56236 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56237 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56238 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56239 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56240 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56241 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56242 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56243 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56244 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56245 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56246 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56247 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56248 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56249 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56250 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56251 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56252 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56253 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56254 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56255 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56256 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56257 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56258 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56259 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56260 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56261 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56262 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56263 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56264 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56265 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56266 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56267 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56268 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56269 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56270 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56271 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56272 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56273 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56274 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56275 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56276 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56277 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56278 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56279 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56280 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56281 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56282 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56283 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56284 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56285 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56286 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56287 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56288 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56289 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56290 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56291 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56292 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56293 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56294 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56295 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56296 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56297 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56298 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56299 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56300 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56301 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56302 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56303 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56304 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56305 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56306 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56307 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56308 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56309 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56310 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56311 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56312 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56313 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56314 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56315 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56316 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56317 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56318 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56319 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56320 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56321 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56322 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56323 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56324 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56325 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56326 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56327 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56328 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56329 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56330 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56331 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56332 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56333 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56334 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56335 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56336 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56337 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56338 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56339 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56340 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56341 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56342 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56343 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56344 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56345 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56346 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56347 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56348 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56349 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56350 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56351 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56352 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56353 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56354 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56355 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56356 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56357 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56358 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56359 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56360 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56361 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56362 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56363 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56364 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56365 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56366 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56367 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56368 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56369 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56370 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56371 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56372 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56373 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56374 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56375
56376 // Initialize threading, some globals and such
56377 __wxPyPreStart(d);
56378
56379
56380 // Although these are defined in __version__ they need to be here too so
56381 // that an assert can be done to ensure that the wxPython and the wxWindows
56382 // versions match.
56383 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56384 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56385 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56386
56387 }
56388
wxWidgets (Impactor)